Remove SymbolUsageValidator from contexts

2015-07-22 15:35:31 +03:00
parent b75779b425
commit 985336d6cc
13 changed files with 27 additions and 138 deletions
@@ -264,7 +264,7 @@ public class CallResolver {
        return resolveFunctionCall(
                BasicCallResolutionContext.create(
                        trace, scope, call, expectedType, dataFlowInfo, ContextDependency.INDEPENDENT, CheckArgumentTypesMode.CHECK_VALUE_ARGUMENTS,
-                        additionalCheckerProvider.getCallChecker(), additionalCheckerProvider.getSymbolUsageValidator(),
+                        additionalCheckerProvider.getCallChecker(),
                        additionalCheckerProvider.getTypeChecker(), isAnnotationContext)
        );
    }
@@ -345,7 +345,7 @@ public class CallResolver {
                CallMaker.makeCall(ReceiverValue.NO_RECEIVER, null, call),
                NO_EXPECTED_TYPE,
                dataFlowInfo, ContextDependency.INDEPENDENT, CheckArgumentTypesMode.CHECK_VALUE_ARGUMENTS,
-                callChecker, additionalCheckerProvider.getSymbolUsageValidator(), additionalCheckerProvider.getTypeChecker(), false);
+                callChecker, additionalCheckerProvider.getTypeChecker(), false);

        if (call.getCalleeExpression() == null) return checkArgumentTypesAndFail(context);

@@ -26,7 +26,6 @@ import org.jetbrains.kotlin.resolve.calls.checkers.CallChecker;
 import org.jetbrains.kotlin.resolve.calls.model.MutableDataFlowInfoForArguments;
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo;
 import org.jetbrains.kotlin.resolve.scopes.JetScope;
-import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator;
 import org.jetbrains.kotlin.types.JetType;

 public class BasicCallResolutionContext extends CallResolutionContext<BasicCallResolutionContext> {
@@ -41,7 +40,6 @@ public class BasicCallResolutionContext extends CallResolutionContext<BasicCallR
            @NotNull ResolutionResultsCache resolutionResultsCache,
            @Nullable MutableDataFlowInfoForArguments dataFlowInfoForArguments,
            @NotNull CallChecker callChecker,
-            @NotNull SymbolUsageValidator symbolUsageValidator,
            @NotNull AdditionalTypeChecker additionalTypeChecker,
            @NotNull StatementFilter statementFilter,
            boolean isAnnotationContext,
@@ -49,7 +47,7 @@ public class BasicCallResolutionContext extends CallResolutionContext<BasicCallR
            boolean insideSafeCallChain
    ) {
        super(trace, scope, call, expectedType, dataFlowInfo, contextDependency, checkArguments, resolutionResultsCache,
-              dataFlowInfoForArguments, callChecker, symbolUsageValidator, additionalTypeChecker, statementFilter, isAnnotationContext, collectAllCandidates, insideSafeCallChain);
+              dataFlowInfoForArguments, callChecker, additionalTypeChecker, statementFilter, isAnnotationContext, collectAllCandidates, insideSafeCallChain);
    }

    @NotNull
@@ -62,13 +60,12 @@ public class BasicCallResolutionContext extends CallResolutionContext<BasicCallR
            @NotNull ContextDependency contextDependency,
            @NotNull CheckArgumentTypesMode checkArguments,
            @NotNull CallChecker callChecker,
-            @NotNull SymbolUsageValidator symbolUsageValidator,
            @NotNull AdditionalTypeChecker additionalTypeChecker,
            boolean isAnnotationContext
    ) {
        return new BasicCallResolutionContext(trace, scope, call, expectedType, dataFlowInfo, contextDependency, checkArguments,
-             new ResolutionResultsCacheImpl(), null,
-             callChecker, symbolUsageValidator, additionalTypeChecker, StatementFilter.NONE, isAnnotationContext, false, false);
+                                              new ResolutionResultsCacheImpl(), null,
+                                              callChecker, additionalTypeChecker, StatementFilter.NONE, isAnnotationContext, false, false);
    }

    @NotNull
@@ -79,7 +76,7 @@ public class BasicCallResolutionContext extends CallResolutionContext<BasicCallR
        return new BasicCallResolutionContext(
                context.trace, context.scope, call, context.expectedType, context.dataFlowInfo, context.contextDependency, checkArguments,
                context.resolutionResultsCache, dataFlowInfoForArguments,
-                context.callChecker, context.symbolUsageValidator, context.additionalTypeChecker,
+                context.callChecker, context.additionalTypeChecker,
                context.statementFilter, context.isAnnotationContext, context.collectAllCandidates, context.insideCallChain);
    }

@@ -104,13 +101,13 @@ public class BasicCallResolutionContext extends CallResolutionContext<BasicCallR
    ) {
        return new BasicCallResolutionContext(
                trace, scope, call, expectedType, dataFlowInfo, contextDependency, checkArguments, resolutionResultsCache,
-                dataFlowInfoForArguments, callChecker, symbolUsageValidator, additionalTypeChecker, statementFilter, isAnnotationContext, collectAllCandidates, insideSafeCallChain);
+                dataFlowInfoForArguments, callChecker, additionalTypeChecker, statementFilter, isAnnotationContext, collectAllCandidates, insideSafeCallChain);
    }

    @NotNull
    public BasicCallResolutionContext replaceCall(@NotNull Call newCall) {
        return new BasicCallResolutionContext(
                trace, scope, newCall, expectedType, dataFlowInfo, contextDependency, checkArguments, resolutionResultsCache,
-                dataFlowInfoForArguments, callChecker, symbolUsageValidator, additionalTypeChecker, statementFilter, isAnnotationContext, collectAllCandidates, insideCallChain);
+                dataFlowInfoForArguments, callChecker, additionalTypeChecker, statementFilter, isAnnotationContext, collectAllCandidates, insideCallChain);
    }
 }
@@ -30,7 +30,6 @@ import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo;
 import org.jetbrains.kotlin.resolve.calls.tasks.TracingStrategy;
 import org.jetbrains.kotlin.resolve.scopes.JetScope;
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue;
-import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator;
 import org.jetbrains.kotlin.types.JetType;

 public final class CallCandidateResolutionContext<D extends CallableDescriptor> extends CallResolutionContext<CallCandidateResolutionContext<D>> {
@@ -56,7 +55,6 @@ public final class CallCandidateResolutionContext<D extends CallableDescriptor>
            @NotNull ResolutionResultsCache resolutionResultsCache,
            @Nullable MutableDataFlowInfoForArguments dataFlowInfoForArguments,
            @NotNull CallChecker callChecker,
-            @NotNull SymbolUsageValidator symbolUsageValidator,
            @NotNull AdditionalTypeChecker additionalTypeChecker,
            @NotNull StatementFilter statementFilter,
            @NotNull ReceiverValue explicitExtensionReceiverForInvoke,
@@ -66,7 +64,7 @@ public final class CallCandidateResolutionContext<D extends CallableDescriptor>
            boolean insideSafeCallChain
    ) {
        super(trace, scope, call, expectedType, dataFlowInfo, contextDependency, checkArguments, resolutionResultsCache,
-              dataFlowInfoForArguments, callChecker, symbolUsageValidator, additionalTypeChecker, statementFilter, isAnnotationContext, 
+              dataFlowInfoForArguments, callChecker, additionalTypeChecker, statementFilter, isAnnotationContext,
              collectAllCandidates, insideSafeCallChain);
        this.candidateCall = candidateCall;
        this.tracing = tracing;
@@ -84,7 +82,7 @@ public final class CallCandidateResolutionContext<D extends CallableDescriptor>
                candidateCall, tracing, trace, context.scope, call, context.expectedType,
                context.dataFlowInfo, context.contextDependency, context.checkArguments,
                context.resolutionResultsCache, context.dataFlowInfoForArguments,
-                context.callChecker, context.symbolUsageValidator, context.additionalTypeChecker, context.statementFilter, explicitExtensionReceiverForInvoke,
+                context.callChecker, context.additionalTypeChecker, context.statementFilter, explicitExtensionReceiverForInvoke,
                candidateResolveMode, context.isAnnotationContext, context.collectAllCandidates, context.insideCallChain);
    }

@@ -95,7 +93,7 @@ public final class CallCandidateResolutionContext<D extends CallableDescriptor>
        return new CallCandidateResolutionContext<D>(
                candidateCall, tracing, context.trace, context.scope, context.call, context.expectedType,
                context.dataFlowInfo, context.contextDependency, context.checkArguments, context.resolutionResultsCache,
-                context.dataFlowInfoForArguments, context.callChecker, context.symbolUsageValidator, context.additionalTypeChecker, context.statementFilter,
+                context.dataFlowInfoForArguments, context.callChecker, context.additionalTypeChecker, context.statementFilter,
                ReceiverValue.NO_RECEIVER, CandidateResolveMode.FULLY, context.isAnnotationContext, context.collectAllCandidates, context.insideCallChain);
    }

@@ -113,7 +111,7 @@ public final class CallCandidateResolutionContext<D extends CallableDescriptor>
    ) {
        return new CallCandidateResolutionContext<D>(
                candidateCall, tracing, trace, scope, call, expectedType, dataFlowInfo, contextDependency, checkArguments,
-                resolutionResultsCache, dataFlowInfoForArguments, callChecker, symbolUsageValidator, additionalTypeChecker, statementFilter,
+                resolutionResultsCache, dataFlowInfoForArguments, callChecker, additionalTypeChecker, statementFilter,
                explicitExtensionReceiverForInvoke, candidateResolveMode, isAnnotationContext, collectAllCandidates, insideSafeCallChain);
    }
 }
@@ -27,7 +27,6 @@ import org.jetbrains.kotlin.resolve.calls.model.DataFlowInfoForArgumentsImpl;
 import org.jetbrains.kotlin.resolve.calls.model.MutableDataFlowInfoForArguments;
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo;
 import org.jetbrains.kotlin.resolve.scopes.JetScope;
-import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator;
 import org.jetbrains.kotlin.types.JetType;

 public abstract class CallResolutionContext<Context extends CallResolutionContext<Context>> extends ResolutionContext<Context> {
@@ -50,14 +49,13 @@ public abstract class CallResolutionContext<Context extends CallResolutionContex
            @SuppressWarnings("NullableProblems")
            @Nullable MutableDataFlowInfoForArguments dataFlowInfoForArguments,
            @NotNull CallChecker callChecker,
-            SymbolUsageValidator symbolUsageValidator,
            @NotNull AdditionalTypeChecker additionalTypeChecker,
            @NotNull StatementFilter statementFilter,
            boolean isAnnotationContext,
            boolean collectAllCandidates,
            boolean insideSafeCallChain
    ) {
-        super(trace, scope, expectedType, dataFlowInfo, contextDependency, resolutionResultsCache, callChecker, symbolUsageValidator,
+        super(trace, scope, expectedType, dataFlowInfo, contextDependency, resolutionResultsCache, callChecker,
              additionalTypeChecker,
              statementFilter, isAnnotationContext, collectAllCandidates, insideSafeCallChain);
        this.call = call;
@@ -24,7 +24,6 @@ import org.jetbrains.kotlin.resolve.calls.checkers.AdditionalTypeChecker;
 import org.jetbrains.kotlin.resolve.calls.checkers.CallChecker;
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo;
 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.TypeUtils;

@@ -50,8 +49,6 @@ public abstract class ResolutionContext<Context extends ResolutionContext<Contex
    @NotNull
    public final CallChecker callChecker;
    @NotNull
-    public final SymbolUsageValidator symbolUsageValidator;
-    @NotNull
    public final StatementFilter statementFilter;

    public final AdditionalTypeChecker additionalTypeChecker;
@@ -71,7 +68,6 @@ public abstract class ResolutionContext<Context extends ResolutionContext<Contex
            @NotNull ContextDependency contextDependency,
            @NotNull ResolutionResultsCache resolutionResultsCache,
            @NotNull CallChecker callChecker,
-            @NotNull SymbolUsageValidator symbolUsageValidator,
            @NotNull AdditionalTypeChecker additionalTypeChecker,
            @NotNull StatementFilter statementFilter,
            boolean isAnnotationContext,
@@ -85,7 +81,6 @@ public abstract class ResolutionContext<Context extends ResolutionContext<Contex
        this.contextDependency = contextDependency;
        this.resolutionResultsCache = resolutionResultsCache;
        this.callChecker = callChecker;
-        this.symbolUsageValidator = symbolUsageValidator;
        this.statementFilter = statementFilter;
        this.additionalTypeChecker = additionalTypeChecker;
        this.isAnnotationContext = isAnnotationContext;
@@ -1,82 +0,0 @@
-/*
- * Copyright 2010-2015 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.calls.context;
-
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.resolve.BindingTrace;
-import org.jetbrains.kotlin.resolve.StatementFilter;
-import org.jetbrains.kotlin.resolve.calls.checkers.AdditionalTypeChecker;
-import org.jetbrains.kotlin.resolve.calls.checkers.CallChecker;
-import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo;
-import org.jetbrains.kotlin.resolve.scopes.JetScope;
-import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator;
-import org.jetbrains.kotlin.types.JetType;
-
-public class SimpleResolutionContext extends ResolutionContext<SimpleResolutionContext> {
-    private SimpleResolutionContext(
-            @NotNull BindingTrace trace,
-            @NotNull JetScope scope,
-            @NotNull JetType expectedType,
-            @NotNull DataFlowInfo dataFlowInfo,
-            @NotNull ContextDependency contextDependency,
-            @NotNull ResolutionResultsCache resolutionResultsCache,
-            @NotNull CallChecker callChecker,
-            @NotNull SymbolUsageValidator symbolUsageValidator,
-            @NotNull AdditionalTypeChecker additionalTypeChecker,
-            @NotNull StatementFilter statementFilter,
-            boolean isAnnotationContext,
-            boolean collectAllCandidates,
-            boolean insideSafeCallChain
-    ) {
-        super(trace, scope, expectedType, dataFlowInfo, contextDependency, resolutionResultsCache, callChecker, symbolUsageValidator,
-              additionalTypeChecker,
-              statementFilter, isAnnotationContext, collectAllCandidates, insideSafeCallChain);
-    }
-
-    public SimpleResolutionContext(
-            @NotNull BindingTrace trace,
-            @NotNull JetScope scope,
-            @NotNull JetType expectedType,
-            @NotNull DataFlowInfo dataFlowInfo,
-            @NotNull ContextDependency contextDependency,
-            @NotNull CallChecker callChecker,
-            @NotNull SymbolUsageValidator symbolUsageValidator,
-            @NotNull AdditionalTypeChecker additionalTypeChecker,
-            @NotNull StatementFilter statementFilter
-    ) {
-        this(trace, scope, expectedType, dataFlowInfo, contextDependency, new ResolutionResultsCacheImpl(),
-             callChecker, symbolUsageValidator, additionalTypeChecker, statementFilter, false, false, false);
-    }
-
-    @Override
-    protected SimpleResolutionContext create(
-            @NotNull BindingTrace trace,
-            @NotNull JetScope scope,
-            @NotNull DataFlowInfo dataFlowInfo,
-            @NotNull JetType expectedType,
-            @NotNull ContextDependency contextDependency,
-            @NotNull ResolutionResultsCache resolutionResultsCache,
-            @NotNull StatementFilter statementFilter,
-            boolean collectAllCandidates,
-            boolean insideSafeCallChain
-    ) {
-        return new SimpleResolutionContext(
-                trace, scope, expectedType, dataFlowInfo, contextDependency, resolutionResultsCache,
-                callChecker, symbolUsageValidator, additionalTypeChecker,
-                statementFilter, isAnnotationContext, collectAllCandidates, insideSafeCallChain);
-    }
-}
@@ -31,7 +31,6 @@ import org.jetbrains.kotlin.resolve.calls.model.MutableDataFlowInfoForArguments;
 import org.jetbrains.kotlin.resolve.calls.model.MutableResolvedCall;
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo;
 import org.jetbrains.kotlin.resolve.scopes.JetScope;
-import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator;
 import org.jetbrains.kotlin.types.JetType;

 import java.util.Collection;
@@ -57,7 +56,6 @@ public class ResolutionTask<D extends CallableDescriptor, F extends D> extends C
            @NotNull ResolutionResultsCache resolutionResultsCache,
            @Nullable MutableDataFlowInfoForArguments dataFlowInfoForArguments,
            @NotNull CallChecker callChecker,
-            @NotNull SymbolUsageValidator symbolUsageValidator,
            @NotNull AdditionalTypeChecker additionalTypeChecker,
            @NotNull StatementFilter statementFilter,
            @NotNull Collection<MutableResolvedCall<F>> resolvedCalls,
@@ -66,7 +64,7 @@ public class ResolutionTask<D extends CallableDescriptor, F extends D> extends C
            boolean insideSafeCallChain
    ) {
        super(trace, scope, call, expectedType, dataFlowInfo, contextDependency, checkArguments, resolutionResultsCache,
-              dataFlowInfoForArguments, callChecker, symbolUsageValidator, additionalTypeChecker, statementFilter, isAnnotationContext, collectAllCandidates, insideSafeCallChain);
+              dataFlowInfoForArguments, callChecker, additionalTypeChecker, statementFilter, isAnnotationContext, collectAllCandidates, insideSafeCallChain);
        this.lazyCandidates = lazyCandidates;
        this.resolvedCalls = resolvedCalls;
        this.tracing = tracing;
@@ -81,7 +79,7 @@ public class ResolutionTask<D extends CallableDescriptor, F extends D> extends C
             context.trace, context.scope, context.call,
             context.expectedType, context.dataFlowInfo, context.contextDependency, context.checkArguments,
             context.resolutionResultsCache, context.dataFlowInfoForArguments,
-             context.callChecker, context.symbolUsageValidator, context.additionalTypeChecker,
+             context.callChecker, context.additionalTypeChecker,
             context.statementFilter, new SmartList<MutableResolvedCall<F>>(),
             context.isAnnotationContext, context.collectAllCandidates, context.insideCallChain);
    }
@@ -115,7 +113,7 @@ public class ResolutionTask<D extends CallableDescriptor, F extends D> extends C
        return new ResolutionTask<D, F>(
                lazyCandidates, tracing, trace, scope, call, expectedType, dataFlowInfo, contextDependency, checkArguments,
                resolutionResultsCache, dataFlowInfoForArguments,
-                callChecker, symbolUsageValidator, additionalTypeChecker,
+                callChecker, additionalTypeChecker,
                statementFilter, resolvedCalls,
                isAnnotationContext, collectAllCandidates, insideSafeCallChain);
    }
@@ -31,17 +31,10 @@ import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType
 import org.jetbrains.kotlin.resolve.*
 import org.jetbrains.kotlin.resolve.calls.ArgumentTypeResolver
 import org.jetbrains.kotlin.resolve.calls.callUtil.getResolvedCall
-import org.jetbrains.kotlin.resolve.calls.checkers.AdditionalTypeChecker
-import org.jetbrains.kotlin.resolve.calls.checkers.CompositeChecker
-import org.jetbrains.kotlin.resolve.calls.context.ContextDependency
-import org.jetbrains.kotlin.resolve.calls.context.SimpleResolutionContext
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedValueArgument
-import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo
 import org.jetbrains.kotlin.resolve.calls.tasks.ExplicitReceiverKind
 import org.jetbrains.kotlin.resolve.constants.*
-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.TypeUtils
 import org.jetbrains.kotlin.types.checker.JetTypeChecker
@@ -54,7 +54,6 @@ import org.jetbrains.kotlin.resolve.calls.tasks.ResolutionCandidate;
 import org.jetbrains.kotlin.resolve.calls.tasks.TracingStrategy;
 import org.jetbrains.kotlin.resolve.calls.util.CallMaker;
 import org.jetbrains.kotlin.resolve.constants.*;
-import org.jetbrains.kotlin.resolve.constants.evaluate.ConstantExpressionEvaluator;
 import org.jetbrains.kotlin.resolve.scopes.WritableScopeImpl;
 import org.jetbrains.kotlin.resolve.scopes.receivers.ExpressionReceiver;
 import org.jetbrains.kotlin.types.*;
@@ -431,7 +430,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
    }

    @NotNull // No class receivers
-    private static LabelResolver.LabeledReceiverResolutionResult resolveToReceiver(
+    private LabelResolver.LabeledReceiverResolutionResult resolveToReceiver(
            JetInstanceExpressionWithLabel expression,
            ExpressionTypingContext context,
            boolean onlyClassReceivers
@@ -471,7 +470,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
        }
    }

-    private static void recordThisOrSuperCallInTraceAndCallExtension(
+    private void recordThisOrSuperCallInTraceAndCallExtension(
            ExpressionTypingContext context,
            ReceiverParameterDescriptor descriptor,
            JetExpression expression
@@ -494,7 +493,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {

        BasicCallResolutionContext resolutionContext = BasicCallResolutionContext.create(context, call, CheckArgumentTypesMode.CHECK_CALLABLE_TYPE);
        context.callChecker.check(resolvedCall, resolutionContext);
-        context.symbolUsageValidator.validateCall(descriptor, trace, expression);
+        components.symbolUsageValidator.validateCall(descriptor, trace, expression);
    }

    private static boolean isDeclaredInClass(ReceiverParameterDescriptor receiver) {
@@ -901,7 +900,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
                result = false;
            } else {
                if (setter != null) {
-                    context.symbolUsageValidator.validateCall(setter, trace, reportOn);
+                    components.symbolUsageValidator.validateCall(setter, trace, reportOn);
                }
            }
        }
@@ -22,15 +22,14 @@ import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider;
 import org.jetbrains.kotlin.resolve.BindingTrace;
 import org.jetbrains.kotlin.resolve.StatementFilter;
 import org.jetbrains.kotlin.resolve.calls.checkers.AdditionalTypeChecker;
+import org.jetbrains.kotlin.resolve.calls.checkers.CallChecker;
 import org.jetbrains.kotlin.resolve.calls.context.ContextDependency;
 import org.jetbrains.kotlin.resolve.calls.context.ResolutionContext;
 import org.jetbrains.kotlin.resolve.calls.context.ResolutionResultsCache;
 import org.jetbrains.kotlin.resolve.calls.context.ResolutionResultsCacheImpl;
-import org.jetbrains.kotlin.resolve.calls.checkers.CallChecker;
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo;
 import org.jetbrains.kotlin.resolve.constants.CompileTimeConstantChecker;
 import org.jetbrains.kotlin.resolve.scopes.JetScope;
-import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator;
 import org.jetbrains.kotlin.types.JetType;

 public class ExpressionTypingContext extends ResolutionContext<ExpressionTypingContext> {
@@ -58,7 +57,6 @@ public class ExpressionTypingContext extends ResolutionContext<ExpressionTypingC
        return newContext(trace, scope, dataFlowInfo, expectedType,
                          ContextDependency.INDEPENDENT, new ResolutionResultsCacheImpl(),
                          callChecker != null ? callChecker : additionalCheckerProvider.getCallChecker(),
-                          additionalCheckerProvider.getSymbolUsageValidator(),
                          additionalCheckerProvider.getTypeChecker(),
                          StatementFilter.NONE, false);
    }
@@ -68,7 +66,7 @@ public class ExpressionTypingContext extends ResolutionContext<ExpressionTypingC
        return new ExpressionTypingContext(
                context.trace, context.scope, context.dataFlowInfo, context.expectedType,
                context.contextDependency, context.resolutionResultsCache,
-                context.callChecker, context.symbolUsageValidator, context.additionalTypeChecker,
+                context.callChecker, context.additionalTypeChecker,
                context.statementFilter,
                context.isAnnotationContext, context.collectAllCandidates, context.insideCallChain
        );
@@ -83,13 +81,12 @@ public class ExpressionTypingContext extends ResolutionContext<ExpressionTypingC
            @NotNull ContextDependency contextDependency,
            @NotNull ResolutionResultsCache resolutionResultsCache,
            @NotNull CallChecker callChecker,
-            @NotNull SymbolUsageValidator symbolUsageValidator,
            @NotNull AdditionalTypeChecker additionalTypeChecker,
            @NotNull StatementFilter statementFilter,
            boolean isAnnotationContext
    ) {
        return new ExpressionTypingContext(
-                trace, scope, dataFlowInfo, expectedType, contextDependency, resolutionResultsCache, callChecker, symbolUsageValidator,
+                trace, scope, dataFlowInfo, expectedType, contextDependency, resolutionResultsCache, callChecker,
                additionalTypeChecker,
                statementFilter, isAnnotationContext, false, false);
    }
@@ -104,7 +101,6 @@ public class ExpressionTypingContext extends ResolutionContext<ExpressionTypingC
            @NotNull ContextDependency contextDependency,
            @NotNull ResolutionResultsCache resolutionResultsCache,
            @NotNull CallChecker callChecker,
-            @NotNull SymbolUsageValidator symbolUsageValidator,
            @NotNull AdditionalTypeChecker additionalTypeChecker,
            @NotNull StatementFilter statementFilter,
            boolean isAnnotationContext,
@@ -112,7 +108,7 @@ public class ExpressionTypingContext extends ResolutionContext<ExpressionTypingC
            boolean insideSafeCallChain
    ) {
        super(trace, scope, expectedType, dataFlowInfo, contextDependency, resolutionResultsCache,
-              callChecker, symbolUsageValidator, additionalTypeChecker,
+              callChecker, additionalTypeChecker,
              statementFilter, isAnnotationContext, collectAllCandidates, insideSafeCallChain);
    }

@@ -130,7 +126,7 @@ public class ExpressionTypingContext extends ResolutionContext<ExpressionTypingC
    ) {
        return new ExpressionTypingContext(trace, scope, dataFlowInfo,
                                           expectedType, contextDependency, resolutionResultsCache,
-                                           callChecker, symbolUsageValidator, additionalTypeChecker,
+                                           callChecker, additionalTypeChecker,
                                           statementFilter, isAnnotationContext, collectAllCandidates, insideSafeCallChain);
    }

@@ -33,7 +33,6 @@ import org.jetbrains.kotlin.resolve.calls.context.ContextDependency
 import org.jetbrains.kotlin.resolve.calls.util.DelegatingCall
 import org.jetbrains.kotlin.resolve.scopes.ChainedScope
 import org.jetbrains.kotlin.resolve.scopes.ExplicitImportsScope
-import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator
 import org.jetbrains.kotlin.types.TypeUtils
 import org.jetbrains.kotlin.util.descriptorsEqualWithSubstitution
 import java.util.ArrayList
@@ -166,7 +165,7 @@ public class ShadowedDeclarationsFilter(
        val dataFlowInfo = bindingContext.getDataFlowInfo(calleeExpression)
        val context = BasicCallResolutionContext.create(bindingTrace, resolutionScope, newCall, TypeUtils.NO_EXPECTED_TYPE, dataFlowInfo,
                                                        ContextDependency.INDEPENDENT, CheckArgumentTypesMode.CHECK_VALUE_ARGUMENTS,
-                                                        CompositeChecker(listOf()), SymbolUsageValidator.Empty, AdditionalTypeChecker.Composite(listOf()), false)
+                                                        CompositeChecker(listOf()), AdditionalTypeChecker.Composite(listOf()), false)
        val callResolver = createContainerForMacros(project, moduleDescriptor).callResolver
        val results = if (isFunction) callResolver.resolveFunctionCall(context) else callResolver.resolveSimpleProperty(context)
        val resultingDescriptors = results.getResultingCalls().map { it.getResultingDescriptor() }
@@ -44,7 +44,6 @@ import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
 import org.jetbrains.kotlin.resolve.calls.results.OverloadResolutionResults
 import org.jetbrains.kotlin.resolve.calls.results.ResolutionStatus
 import org.jetbrains.kotlin.resolve.calls.util.DelegatingCall
-import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator
 import org.jetbrains.kotlin.types.JetType
 import org.jetbrains.kotlin.types.TypeUtils
 import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils
@@ -181,7 +180,7 @@ class ExpectedInfos(
        val bindingTrace = DelegatingBindingTrace(bindingContext, "Temporary trace for completion")
        val context = BasicCallResolutionContext.create(bindingTrace, resolutionScope, truncatedCall, callExpectedType, dataFlowInfo,
                                                        ContextDependency.INDEPENDENT, CheckArgumentTypesMode.CHECK_VALUE_ARGUMENTS,
-                                                        CompositeChecker(listOf()), SymbolUsageValidator.Empty, AdditionalTypeChecker.Composite(listOf()), false)
+                                                        CompositeChecker(listOf()), AdditionalTypeChecker.Composite(listOf()), false)
        val callResolutionContext = context.replaceCollectAllCandidates(true)
        val callResolver = createContainerForMacros(project, moduleDescriptor).callResolver
        val results: OverloadResolutionResults<FunctionDescriptor> = callResolver.resolveFunctionCall(callResolutionContext)
@@ -40,7 +40,6 @@ import org.jetbrains.kotlin.resolve.calls.smartcasts.SmartCastUtils
 import org.jetbrains.kotlin.resolve.lazy.ResolveSessionUtils
 import org.jetbrains.kotlin.resolve.scopes.receivers.ExpressionReceiver
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue
-import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator
 import org.jetbrains.kotlin.types.JetType
 import org.jetbrains.kotlin.utils.addIfNotNull
 import org.jetbrains.kotlin.utils.addToStdlib.singletonOrEmptyList