Fix "rewrite at slice LEXICAL_SCOPE" during callable reference resolution

Following the TODO in CallableReferencesResolutionUtils.kt, delete the
suspicious scope and use the new resolution process with the qualifier which
was obtained after the resolution of LHS. However, by default the tower
resolution algorithm also considers each qualifier as a class value as well,
which would be wrong here because resolution of LHS as a "value" happens
earlier in DoubleColonExpressionResolver and with slightly different rules. To
avoid that, do not mix in the "explicit receiver" scope tower processor when
creating processors for callable reference resolution.

Also delete unused functions and classes related to deleted scope, refactor
Scopes.kt

 #KT-8596 Fixed

compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/tower/ScopeTowerProcessors.kt

@@ -129,6 +129,7 @@ private class NoExplicitReceiverScopeTowerProcessor<D : CallableDescriptor, C: C
 private fun <D : CallableDescriptor, C: Candidate<D>> createSimpleProcessor(
         context: TowerContext<D, C>,
         explicitReceiver: Receiver?,
+        classValueReceiver: Boolean,
         collectCandidates: ScopeTowerLevel.(name: Name, extensionReceiver: ReceiverValue?) -> Collection<CandidateWithBoundDispatchReceiver<D>>
 ) : ScopeTowerProcessor<C> {
     if (explicitReceiver is ReceiverValue) {
@@ -136,6 +137,7 @@ private fun <D : CallableDescriptor, C: Candidate<D>> createSimpleProcessor(
     }
     else if (explicitReceiver is QualifierReceiver) {
         val qualifierProcessor = QualifierScopeTowerProcessor(context, explicitReceiver, collectCandidates)
+        if (!classValueReceiver) return qualifierProcessor
 
         // todo enum entry, object.
         val classValue = explicitReceiver.classValueReceiver ?: return qualifierProcessor
@@ -152,14 +154,17 @@ private fun <D : CallableDescriptor, C: Candidate<D>> createSimpleProcessor(
     }
 }
 
-fun <C : Candidate<VariableDescriptor>> createVariableProcessor(context: TowerContext<VariableDescriptor, C>, explicitReceiver: Receiver?)
-        = createSimpleProcessor(context, explicitReceiver, ScopeTowerLevel::getVariables)
+fun <C : Candidate<VariableDescriptor>> createVariableProcessor(
+        context: TowerContext<VariableDescriptor, C>, explicitReceiver: Receiver?, classValueReceiver: Boolean = true
+) = createSimpleProcessor(context, explicitReceiver, classValueReceiver, ScopeTowerLevel::getVariables)
 
-fun <C : Candidate<VariableDescriptor>> createVariableAndObjectProcessor(context: TowerContext<VariableDescriptor, C>, explicitReceiver: Receiver?) =
-        CompositeScopeTowerProcessor(
-                createVariableProcessor(context, explicitReceiver),
-                createSimpleProcessor(context, explicitReceiver, ScopeTowerLevel::getObjects)
-        )
+fun <C : Candidate<VariableDescriptor>> createVariableAndObjectProcessor(
+        context: TowerContext<VariableDescriptor, C>, explicitReceiver: Receiver?, classValueReceiver: Boolean = true
+) = CompositeScopeTowerProcessor(
+        createVariableProcessor(context, explicitReceiver),
+        createSimpleProcessor(context, explicitReceiver, classValueReceiver, ScopeTowerLevel::getObjects)
+)
 
-fun <C : Candidate<FunctionDescriptor>> createFunctionProcessor(context: TowerContext<FunctionDescriptor, C>, explicitReceiver: Receiver?)
-        = createSimpleProcessor(context, explicitReceiver, ScopeTowerLevel::getFunctions)
+fun <C : Candidate<FunctionDescriptor>> createFunctionProcessor(
+        context: TowerContext<FunctionDescriptor, C>, explicitReceiver: Receiver?, classValueReceiver: Boolean = true
+) = createSimpleProcessor(context, explicitReceiver, classValueReceiver, ScopeTowerLevel::getFunctions)

compiler/resolution/src/org/jetbrains/kotlin/resolve/scopes/FilteringScope.kt

@@ -1,48 +0,0 @@
-/*
- * Copyright 2010-2016 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.jetbrains.kotlin.resolve.scopes
-
-import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
-import org.jetbrains.kotlin.incremental.components.LookupLocation
-import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.utils.Printer
-
-class FilteringScope(private val workerScope: MemberScope, private val predicate: (DeclarationDescriptor) -> Boolean) : MemberScope {
-
-    override fun getContributedFunctions(name: Name, location: LookupLocation) = workerScope.getContributedFunctions(name, location).filter(predicate)
-
-    private fun <D : DeclarationDescriptor> filterDescriptor(descriptor: D?): D?
-            = if (descriptor != null && predicate(descriptor)) descriptor else null
-
-    override fun getContributedClassifier(name: Name, location: LookupLocation) = filterDescriptor(workerScope.getContributedClassifier(name, location))
-
-    override fun getContributedVariables(name: Name, location: LookupLocation) = workerScope.getContributedVariables(name, location).filter(predicate)
-
-    override fun getContributedDescriptors(kindFilter: DescriptorKindFilter,
-                                           nameFilter: (Name) -> Boolean) = workerScope.getContributedDescriptors(kindFilter, nameFilter).filter(predicate)
-
-    override fun printScopeStructure(p: Printer) {
-        p.println(javaClass.simpleName, " {")
-        p.pushIndent()
-
-        p.print("workerScope = ")
-        workerScope.printScopeStructure(p.withholdIndentOnce())
-
-        p.popIndent()
-        p.println("}")
-    }
-}

compiler/resolution/src/org/jetbrains/kotlin/resolve/scopes/ScopeUtils.java

@@ -20,23 +20,14 @@ import kotlin.Unit;
 import kotlin.jvm.functions.Function1;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.descriptors.*;
+import org.jetbrains.kotlin.descriptors.PropertyDescriptor;
+import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor;
+import org.jetbrains.kotlin.descriptors.VariableDescriptorWithAccessors;
 import org.jetbrains.kotlin.utils.Printer;
 
 public final class ScopeUtils {
     private ScopeUtils() {}
 
-    @NotNull
-    public static MemberScope getStaticNestedClassesScope(@NotNull ClassDescriptor descriptor) {
-        MemberScope innerClassesScope = descriptor.getUnsubstitutedInnerClassesScope();
-        return new FilteringScope(innerClassesScope, new Function1<DeclarationDescriptor, Boolean>() {
-            @Override
-            public Boolean invoke(DeclarationDescriptor descriptor) {
-                return descriptor instanceof ClassDescriptor && !((ClassDescriptor) descriptor).isInner();
-            }
-        });
-    }
-
     public static LexicalScope makeScopeForPropertyHeader(
             @NotNull LexicalScope parent,
             @NotNull final PropertyDescriptor propertyDescriptor

compiler/resolution/src/org/jetbrains/kotlin/resolve/scopes/Scopes.kt

@@ -39,17 +39,30 @@ interface LexicalScope: HierarchicalScope {
 
     val kind: LexicalScopeKind
 
-    companion object {
-        fun empty(parent: HierarchicalScope, ownerDescriptor: DeclarationDescriptor): BaseLexicalScope {
-            return object : BaseLexicalScope(parent, ownerDescriptor) {
-                override val kind: LexicalScopeKind get() = LexicalScopeKind.EMPTY
+    class Empty(
+            parent: HierarchicalScope,
+            override val ownerDescriptor: DeclarationDescriptor
+    ) : BaseHierarchicalScope(parent), LexicalScope {
+        override val parent: HierarchicalScope
+            get() = super.parent!!
 
-                override fun printStructure(p: Printer) {
-                    p.println("Empty lexical scope with owner = $ownerDescriptor and parent = ${parent}.")
-                }
-            }
+        override val isOwnerDescriptorAccessibleByLabel: Boolean
+            get() = false
+
+        override val implicitReceiver: ReceiverParameterDescriptor?
+            get() = null
+
+        override val kind: LexicalScopeKind
+            get() = LexicalScopeKind.EMPTY
+
+        override fun printStructure(p: Printer) {
+            p.println("Empty lexical scope with owner = $ownerDescriptor and parent = $parent")
         }
     }
+
+    companion object {
+        fun empty(parent: HierarchicalScope, ownerDescriptor: DeclarationDescriptor): LexicalScope = Empty(parent, ownerDescriptor)
+    }
 }
 
 enum class LexicalScopeKind(val withLocalDescriptors: Boolean) {
@@ -116,20 +129,6 @@ abstract class BaseHierarchicalScope(override val parent: HierarchicalScope?) :
     override fun getContributedFunctions(name: Name, location: LookupLocation): Collection<FunctionDescriptor> = emptyList()
 }
 
-abstract class BaseLexicalScope(
-        parent: HierarchicalScope,
-        override val ownerDescriptor: DeclarationDescriptor
-): BaseHierarchicalScope(parent), LexicalScope {
-    override val parent: HierarchicalScope
-        get() = super.parent!!
-
-    override val isOwnerDescriptorAccessibleByLabel: Boolean
-        get() = false
-
-    override val implicitReceiver: ReceiverParameterDescriptor?
-        get() = null
-}
-
 abstract class BaseImportingScope(parent: ImportingScope?) : BaseHierarchicalScope(parent), ImportingScope {
     override val parent: ImportingScope?
         get() = super.parent as ImportingScope?