Inject SymbolUsageValidator into CallExpressionResolver

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallCompleter.kt

@@ -37,6 +37,7 @@ import org.jetbrains.kotlin.resolve.calls.results.OverloadResolutionResultsImpl
 import org.jetbrains.kotlin.resolve.calls.results.ResolutionStatus
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo
 import org.jetbrains.kotlin.resolve.calls.tasks.TracingStrategy
+import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator
 import org.jetbrains.kotlin.types.ErrorUtils
 import org.jetbrains.kotlin.types.JetType
 import org.jetbrains.kotlin.types.TypeUtils
@@ -44,9 +45,10 @@ import org.jetbrains.kotlin.types.expressions.DataFlowUtils
 import java.util.ArrayList
 
 public class CallCompleter(
-        val argumentTypeResolver: ArgumentTypeResolver,
-        val candidateResolver: CandidateResolver,
-        val builtIns: KotlinBuiltIns
+        private val argumentTypeResolver: ArgumentTypeResolver,
+        private val candidateResolver: CandidateResolver,
+        private val symbolUsageValidator: SymbolUsageValidator,
+        private val builtIns: KotlinBuiltIns
 ) {
     fun <D : CallableDescriptor> completeCall(
             context: BasicCallResolutionContext,
@@ -75,7 +77,7 @@ public class CallCompleter(
                 resolvedCall.variableCall.getCall().getCalleeExpression()
             else
                 resolvedCall.getCall().getCalleeExpression()
-            context.symbolUsageValidator.validateCall(resolvedCall.getResultingDescriptor(), context.trace, element!!)
+            symbolUsageValidator.validateCall(resolvedCall.getResultingDescriptor(), context.trace, element!!)
         }
 
         if (results.isSingleResult() && results.getResultingCall().getStatus().isSuccess()) {

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallExpressionResolver.java

@@ -41,6 +41,7 @@ import org.jetbrains.kotlin.resolve.calls.util.FakeCallableDescriptorForObject;
 import org.jetbrains.kotlin.resolve.constants.CompileTimeConstant;
 import org.jetbrains.kotlin.resolve.constants.evaluate.ConstantExpressionEvaluator;
 import org.jetbrains.kotlin.resolve.scopes.receivers.*;
+import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator;
 import org.jetbrains.kotlin.types.ErrorUtils;
 import org.jetbrains.kotlin.types.JetType;
 import org.jetbrains.kotlin.types.TypeUtils;
@@ -61,10 +62,16 @@ public class CallExpressionResolver {
 
     private final CallResolver callResolver;
     private final ConstantExpressionEvaluator constantExpressionEvaluator;
+    private final SymbolUsageValidator symbolUsageValidator;
 
-    public CallExpressionResolver(@NotNull CallResolver callResolver, @NotNull ConstantExpressionEvaluator constantExpressionEvaluator) {
+    public CallExpressionResolver(
+            @NotNull CallResolver callResolver,
+            @NotNull ConstantExpressionEvaluator constantExpressionEvaluator,
+            @NotNull SymbolUsageValidator symbolUsageValidator
+    ) {
         this.callResolver = callResolver;
         this.constantExpressionEvaluator = constantExpressionEvaluator;
+        this.symbolUsageValidator = symbolUsageValidator;
     }
 
     private ExpressionTypingServices expressionTypingServices;
@@ -120,7 +127,7 @@ public class CallExpressionResolver {
         if (qualifier != null) {
             result[0] = true;
             if (!isLHSOfDot) {
-                resolveAsStandaloneExpression(qualifier, context);
+                resolveAsStandaloneExpression(qualifier, context, symbolUsageValidator);
             }
             return null;
         }
@@ -422,7 +429,7 @@ public class CallExpressionResolver {
         return typeInfo;
     }
 
-    private static void resolveDeferredReceiverInQualifiedExpression(
+    private void resolveDeferredReceiverInQualifiedExpression(
             @Nullable QualifierReceiver qualifierReceiver,
             @NotNull JetQualifiedExpression qualifiedExpression,
             @NotNull ExpressionTypingContext context
@@ -433,7 +440,7 @@ public class CallExpressionResolver {
         DeclarationDescriptor selectorDescriptor =
                 calleeExpression instanceof JetReferenceExpression
                 ? context.trace.get(BindingContext.REFERENCE_TARGET, (JetReferenceExpression) calleeExpression) : null;
-        ReceiversPackage.resolveAsReceiverInQualifiedExpression(qualifierReceiver, context, selectorDescriptor);
+        ReceiversPackage.resolveAsReceiverInQualifiedExpression(qualifierReceiver, context, symbolUsageValidator, selectorDescriptor);
     }
 
     private static void checkNestedClassAccess(

compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/receivers/Qualifier.kt

@@ -36,6 +36,7 @@ import org.jetbrains.kotlin.resolve.descriptorUtil.hasClassObjectType
 import org.jetbrains.kotlin.resolve.scopes.ChainedScope
 import org.jetbrains.kotlin.resolve.scopes.FilteringScope
 import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator
 import org.jetbrains.kotlin.types.JetType
 import org.jetbrains.kotlin.types.expressions.ExpressionTypingContext
 import org.jetbrains.kotlin.utils.addIfNotNull
@@ -131,8 +132,11 @@ fun createQualifier(
     return qualifier
 }
 
-private fun QualifierReceiver.resolveAsStandaloneExpression(context: ExpressionTypingContext): JetType? {
-    resolveAndRecordReferenceTarget(context, selector = null)
+private fun QualifierReceiver.resolveAsStandaloneExpression(
+        context: ExpressionTypingContext,
+        symbolUsageValidator: SymbolUsageValidator
+): JetType? {
+    resolveAndRecordReferenceTarget(context, symbolUsageValidator, selector = null)
     if (classifier is TypeParameterDescriptor) {
         context.trace.report(TYPE_PARAMETER_IS_NOT_AN_EXPRESSION.on(referenceExpression, classifier))
     }
@@ -145,8 +149,12 @@ private fun QualifierReceiver.resolveAsStandaloneExpression(context: ExpressionT
     return null
 }
 
-private fun QualifierReceiver.resolveAsReceiverInQualifiedExpression(context: ExpressionTypingContext, selector: DeclarationDescriptor?) {
-    resolveAndRecordReferenceTarget(context, selector)
+private fun QualifierReceiver.resolveAsReceiverInQualifiedExpression(
+        context: ExpressionTypingContext,
+        symbolUsageValidator: SymbolUsageValidator,
+        selector: DeclarationDescriptor?
+) {
+    resolveAndRecordReferenceTarget(context, symbolUsageValidator, selector)
     if (classifier is TypeParameterDescriptor) {
         context.trace.report(TYPE_PARAMETER_ON_LHS_OF_DOT.on(referenceExpression, classifier))
     }
@@ -155,13 +163,18 @@ private fun QualifierReceiver.resolveAsReceiverInQualifiedExpression(context: Ex
     }
 }
 
-private fun QualifierReceiver.resolveAndRecordReferenceTarget(context: ExpressionTypingContext, selector: DeclarationDescriptor?) {
-    resultingDescriptor = resolveReferenceTarget(context, selector)
+private fun QualifierReceiver.resolveAndRecordReferenceTarget(
+        context: ExpressionTypingContext,
+        symbolUsageValidator: SymbolUsageValidator,
+        selector: DeclarationDescriptor?
+) {
+    resultingDescriptor = resolveReferenceTarget(context, symbolUsageValidator, selector)
     context.trace.record(REFERENCE_TARGET, referenceExpression, resultingDescriptor)
 }
 
 private fun QualifierReceiver.resolveReferenceTarget(
         context: ExpressionTypingContext,
+        symbolUsageValidator: SymbolUsageValidator,
         selector: DeclarationDescriptor?
 ): DeclarationDescriptor {
     if (classifier is TypeParameterDescriptor) {
@@ -183,13 +196,13 @@ private fun QualifierReceiver.resolveReferenceTarget(
 
     val declarationDescriptor = descriptor
     if (declarationDescriptor is ClassifierDescriptor)
-        context.symbolUsageValidator.validateTypeUsage(declarationDescriptor, context.trace, referenceExpression)
+        symbolUsageValidator.validateTypeUsage(declarationDescriptor, context.trace, referenceExpression)
 
     if (isCallableWithReceiver && classifier is ClassDescriptor && classifier.hasClassObjectType) {
         val companionObjectDescriptor = classifier.getCompanionObjectDescriptor()
         if (companionObjectDescriptor != null) {
             context.trace.record(SHORT_REFERENCE_TO_COMPANION_OBJECT, referenceExpression, classifier)
-            context.symbolUsageValidator.validateTypeUsage(companionObjectDescriptor, context.trace, referenceExpression)
+            symbolUsageValidator.validateTypeUsage(companionObjectDescriptor, context.trace, referenceExpression)
             return companionObjectDescriptor
         }
     }