Rename SymbolUsageValidator -> ClassifierUsageChecker

Also validateTypeUsage -> check

compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/platform/JvmPlatformConfigurator.kt

@@ -66,7 +66,7 @@ object JvmPlatformConfigurator : PlatformConfigurator(
                 JavaTypeAccessibilityChecker()
         ),
 
-        additionalSymbolUsageValidators = listOf(),
+        additionalClassifierUsageCheckers = listOf(),
 
         additionalAnnotationCheckers = listOf(
                 RepeatableAnnotationChecker,

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2015 JetBrains s.r.o.
+ * 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.
@@ -14,12 +14,11 @@
  * limitations under the License.
  */
 
-package org.jetbrains.kotlin.resolve.validation
+package org.jetbrains.kotlin.resolve
 
 import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.descriptors.ClassifierDescriptor
-import org.jetbrains.kotlin.resolve.BindingTrace
 
-interface SymbolUsageValidator {
-    fun validateTypeUsage(targetDescriptor: ClassifierDescriptor, trace: BindingTrace, element: PsiElement)
+interface ClassifierUsageChecker {
+    fun check(targetDescriptor: ClassifierDescriptor, trace: BindingTrace, element: PsiElement)
 }

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2015 JetBrains s.r.o.
+ * 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.
@@ -14,19 +14,16 @@
  * limitations under the License.
  */
 
-package org.jetbrains.kotlin.resolve.validation
+package org.jetbrains.kotlin.resolve
 
 import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.descriptors.ClassifierDescriptor
 import org.jetbrains.kotlin.psi.KtAnnotationEntry
 import org.jetbrains.kotlin.psi.KtStubbedPsiUtil
 import org.jetbrains.kotlin.psi.KtSuperTypeCallEntry
-import org.jetbrains.kotlin.resolve.BindingTrace
-import org.jetbrains.kotlin.resolve.createDeprecationDiagnostic
-import org.jetbrains.kotlin.resolve.getDeprecation
 
-class DeprecatedSymbolValidator : SymbolUsageValidator {
-    override fun validateTypeUsage(targetDescriptor: ClassifierDescriptor, trace: BindingTrace, element: PsiElement) {
+class DeprecatedClassifierUsageChecker : ClassifierUsageChecker {
+    override fun check(targetDescriptor: ClassifierDescriptor, trace: BindingTrace, element: PsiElement) {
         // Do not check types in annotation entries to prevent cycles in resolve, rely on call message
         val annotationEntry = KtStubbedPsiUtil.getPsiOrStubParent(element, KtAnnotationEntry::class.java, true)
         if (annotationEntry != null && annotationEntry.calleeExpression!!.constructorReferenceExpression == element) return

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

@@ -22,16 +22,15 @@ import org.jetbrains.kotlin.resolve.descriptorUtil.classValueDescriptor
 import org.jetbrains.kotlin.resolve.descriptorUtil.classValueTypeDescriptor
 import org.jetbrains.kotlin.resolve.descriptorUtil.hasCompanionObject
 import org.jetbrains.kotlin.resolve.scopes.receivers.*
-import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator
 import org.jetbrains.kotlin.types.expressions.ExpressionTypingContext
 
 fun resolveQualifierAsReceiverInExpression(
         qualifier: Qualifier,
         selector: DeclarationDescriptor?,
         context: ExpressionTypingContext,
-        symbolUsageValidators: Iterable<SymbolUsageValidator>
+        classifierUsageCheckers: Iterable<ClassifierUsageChecker>
 ): DeclarationDescriptor {
-    val referenceTarget = resolveQualifierReferenceTarget(qualifier, selector, context, symbolUsageValidators)
+    val referenceTarget = resolveQualifierReferenceTarget(qualifier, selector, context, classifierUsageCheckers)
 
     if (referenceTarget is TypeParameterDescriptor) {
         context.trace.report(Errors.TYPE_PARAMETER_ON_LHS_OF_DOT.on(qualifier.referenceExpression, referenceTarget))
@@ -43,9 +42,9 @@ fun resolveQualifierAsReceiverInExpression(
 fun resolveQualifierAsStandaloneExpression(
         qualifier: Qualifier,
         context: ExpressionTypingContext,
-        symbolUsageValidators: Iterable<SymbolUsageValidator>
+        classifierUsageCheckers: Iterable<ClassifierUsageChecker>
 ): DeclarationDescriptor {
-    val referenceTarget = resolveQualifierReferenceTarget(qualifier, null, context, symbolUsageValidators)
+    val referenceTarget = resolveQualifierReferenceTarget(qualifier, null, context, classifierUsageCheckers)
 
     when (referenceTarget) {
         is TypeParameterDescriptor -> {
@@ -68,7 +67,7 @@ private fun resolveQualifierReferenceTarget(
         qualifier: Qualifier,
         selector: DeclarationDescriptor?,
         context: ExpressionTypingContext,
-        symbolUsageValidators: Iterable<SymbolUsageValidator>
+        classifierUsageCheckers: Iterable<ClassifierUsageChecker>
 ): DeclarationDescriptor {
     if (qualifier is TypeParameterQualifier) {
         return qualifier.descriptor
@@ -104,8 +103,8 @@ private fun resolveQualifierReferenceTarget(
             context.trace.recordType(qualifier.expression, classValueTypeDescriptor.defaultType)
             if (classifier.hasCompanionObject) {
                 context.trace.record(BindingContext.SHORT_REFERENCE_TO_COMPANION_OBJECT, qualifier.referenceExpression, classifier)
-                for (validator in symbolUsageValidators) {
-                    validator.validateTypeUsage(classValueDescriptor, context.trace, qualifier.referenceExpression)
+                for (checker in classifierUsageCheckers) {
+                    checker.check(classValueDescriptor, context.trace, qualifier.referenceExpression)
                 }
             }
             return classValueTypeDescriptor

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

@@ -34,13 +34,12 @@ import org.jetbrains.kotlin.resolve.scopes.receivers.*
 import org.jetbrains.kotlin.resolve.scopes.utils.findClassifier
 import org.jetbrains.kotlin.resolve.scopes.utils.memberScopeAsImportingScope
 import org.jetbrains.kotlin.resolve.source.KotlinSourceElement
-import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator
 import org.jetbrains.kotlin.types.expressions.ExpressionTypingContext
 import org.jetbrains.kotlin.types.expressions.isWithoutValueArguments
 import org.jetbrains.kotlin.utils.addIfNotNull
 import org.jetbrains.kotlin.utils.addToStdlib.check
 
-class QualifiedExpressionResolver(val symbolUsageValidators: Iterable<SymbolUsageValidator>) {
+class QualifiedExpressionResolver(val classifierUsageCheckers: Iterable<ClassifierUsageChecker>) {
     fun resolvePackageHeader(
             packageDirective: KtPackageDirective,
             module: ModuleDescriptor,
@@ -596,8 +595,8 @@ class QualifiedExpressionResolver(val symbolUsageValidators: Iterable<SymbolUsag
         trace.record(BindingContext.REFERENCE_TARGET, referenceExpression, descriptor)
 
         if (descriptor is ClassifierDescriptor) {
-            for (validator in symbolUsageValidators) {
-                validator.validateTypeUsage(descriptor, trace, referenceExpression)
+            for (checker in classifierUsageCheckers) {
+                checker.check(descriptor, trace, referenceExpression)
             }
         }
 

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

@@ -26,9 +26,6 @@ import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.resolve.calls.checkers.*
 import org.jetbrains.kotlin.resolve.calls.results.TypeSpecificityComparator
 import org.jetbrains.kotlin.resolve.scopes.SyntheticScopes
-import org.jetbrains.kotlin.resolve.calls.checkers.DeprecatedCallChecker
-import org.jetbrains.kotlin.resolve.validation.DeprecatedSymbolValidator
-import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator
 import org.jetbrains.kotlin.storage.StorageManager
 import org.jetbrains.kotlin.types.DynamicTypesSettings
 
@@ -72,7 +69,7 @@ private val DEFAULT_CALL_CHECKERS = listOf(
         CoroutineSuspendCallChecker, BuilderFunctionsCallChecker
 )
 private val DEFAULT_TYPE_CHECKERS = emptyList<AdditionalTypeChecker>()
-private val DEFAULT_VALIDATORS = listOf(DeprecatedSymbolValidator())
+private val DEFAULT_CLASSIFIER_USAGE_CHECKERS = listOf(DeprecatedClassifierUsageChecker())
 
 
 abstract class PlatformConfigurator(
@@ -80,7 +77,7 @@ abstract class PlatformConfigurator(
         additionalDeclarationCheckers: List<DeclarationChecker>,
         additionalCallCheckers: List<CallChecker>,
         additionalTypeCheckers: List<AdditionalTypeChecker>,
-        additionalSymbolUsageValidators: List<SymbolUsageValidator>,
+        additionalClassifierUsageCheckers: List<ClassifierUsageChecker>,
         private val additionalAnnotationCheckers: List<AdditionalAnnotationChecker>,
         private val identifierChecker: IdentifierChecker,
         private val overloadFilter: OverloadFilter
@@ -88,7 +85,7 @@ abstract class PlatformConfigurator(
     private val declarationCheckers: List<DeclarationChecker> = DEFAULT_DECLARATION_CHECKERS + additionalDeclarationCheckers
     private val callCheckers: List<CallChecker> = DEFAULT_CALL_CHECKERS + additionalCallCheckers
     private val typeCheckers: List<AdditionalTypeChecker> = DEFAULT_TYPE_CHECKERS + additionalTypeCheckers
-    private val symbolUsageValidators: List<SymbolUsageValidator> = DEFAULT_VALIDATORS + additionalSymbolUsageValidators
+    private val classifierUsageCheckers: List<ClassifierUsageChecker> = DEFAULT_CLASSIFIER_USAGE_CHECKERS + additionalClassifierUsageCheckers
 
     open fun configure(container: StorageComponentContainer) {
         with (container) {
@@ -96,7 +93,7 @@ abstract class PlatformConfigurator(
             declarationCheckers.forEach { useInstance(it) }
             callCheckers.forEach { useInstance(it) }
             typeCheckers.forEach { useInstance(it) }
-            symbolUsageValidators.forEach { useInstance(it) }
+            classifierUsageCheckers.forEach { useInstance(it) }
             additionalAnnotationCheckers.forEach { useInstance(it) }
             useInstance(identifierChecker)
             useInstance(overloadFilter)
@@ -111,4 +108,3 @@ fun TargetPlatform.createModule(
         builtIns: KotlinBuiltIns,
         capabilities: Map<ModuleDescriptor.Capability<*>, Any?> = emptyMap()
 ) = ModuleDescriptorImpl(name, storageManager, defaultModuleParameters, builtIns, capabilities)
-

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

@@ -52,7 +52,6 @@ import org.jetbrains.kotlin.resolve.calls.util.CallMaker
 import org.jetbrains.kotlin.resolve.calls.util.FakeCallableDescriptorForObject
 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.KotlinType
 import org.jetbrains.kotlin.types.TypeUtils
@@ -72,7 +71,7 @@ class CallExpressionResolver(
         private val dataFlowAnalyzer: DataFlowAnalyzer,
         private val builtIns: KotlinBuiltIns,
         private val qualifiedExpressionResolver: QualifiedExpressionResolver,
-        private val symbolUsageValidators: Iterable<SymbolUsageValidator>
+        private val classifierUsageCheckers: Iterable<ClassifierUsageChecker>
 ) {
     private lateinit var expressionTypingServices: ExpressionTypingServices
 
@@ -163,7 +162,7 @@ class CallExpressionResolver(
         val temporaryForQualifier = TemporaryTraceAndCache.create(context, "trace to resolve as qualifier", nameExpression)
         val contextForQualifier = context.replaceTraceAndCache(temporaryForQualifier)
         qualifiedExpressionResolver.resolveNameExpressionAsQualifierForDiagnostics(nameExpression, receiver, contextForQualifier)?.let {
-            resolveQualifierAsStandaloneExpression(it, contextForQualifier, symbolUsageValidators)
+            resolveQualifierAsStandaloneExpression(it, contextForQualifier, classifierUsageCheckers)
             temporaryForQualifier.commit()
         } ?: temporaryForVariable.commit()
         return noTypeInfo(context)
@@ -450,7 +449,7 @@ class CallExpressionResolver(
             context.trace.get(BindingContext.REFERENCE_TARGET, it)
         }
 
-        resolveQualifierAsReceiverInExpression(qualifier, selectorDescriptor, context, symbolUsageValidators)
+        resolveQualifierAsReceiverInExpression(qualifier, selectorDescriptor, context, classifierUsageCheckers)
     }
 
     companion object {

js/js.frontend/src/org/jetbrains/kotlin/js/resolve/JsPlatformConfigurator.kt

@@ -33,7 +33,7 @@ object JsPlatformConfigurator : PlatformConfigurator(
                                                NativeInnerClassChecker()),
         additionalCallCheckers = listOf(),
         additionalTypeCheckers = listOf(),
-        additionalSymbolUsageValidators = listOf(),
+        additionalClassifierUsageCheckers = listOf(),
         additionalAnnotationCheckers = listOf(),
         identifierChecker = IdentifierChecker.DEFAULT,
         overloadFilter = OverloadFilter.DEFAULT