org.jetbrains.kotlin.resolve.VarianceChecker.kt Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of kotlin-compiler-embeddable Show documentation
Show all versions of kotlin-compiler-embeddable Show documentation
the Kotlin compiler embeddable
/*
* 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
import org.jetbrains.kotlin.descriptors.ClassDescriptor
import org.jetbrains.kotlin.diagnostics.Errors
import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
import org.jetbrains.kotlin.types.Variance
import org.jetbrains.kotlin.types.checker.TypeCheckingProcedure.EnrichedProjectionKind.*
import org.jetbrains.kotlin.types.checker.TypeCheckingProcedure.*
import org.jetbrains.kotlin.descriptors.Visibilities
import org.jetbrains.kotlin.resolve.typeBinding.TypeBinding
import com.intellij.psi.PsiElement
import org.jetbrains.kotlin.builtins.KotlinBuiltIns
import org.jetbrains.kotlin.resolve.typeBinding.createTypeBinding
import org.jetbrains.kotlin.resolve.typeBinding.createTypeBindingForReturnType
import org.jetbrains.kotlin.descriptors.CallableDescriptor
import org.jetbrains.kotlin.types.KotlinType
import org.jetbrains.kotlin.types.Variance.*
import org.jetbrains.kotlin.diagnostics.DiagnosticSink
import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
import org.jetbrains.kotlin.descriptors.impl.FunctionDescriptorImpl
import org.jetbrains.kotlin.descriptors.impl.PropertyDescriptorImpl
import org.jetbrains.kotlin.descriptors.impl.PropertyAccessorDescriptorImpl
import org.jetbrains.kotlin.resolve.source.getPsi
import org.jetbrains.kotlin.descriptors.VariableDescriptor
import org.jetbrains.kotlin.psi.*
class ManualVariance(val descriptor: TypeParameterDescriptor, val variance: Variance)
class VarianceChecker(trace: BindingTrace) {
private val core = VarianceCheckerCore(trace.bindingContext, trace)
fun check(c: TopDownAnalysisContext) {
core.check(c)
}
}
class VarianceConflictDiagnosticData(
val containingType: KotlinType,
val typeParameter: TypeParameterDescriptor,
val occurrencePosition: Variance
)
class VarianceCheckerCore(
private val context: BindingContext,
private val diagnosticSink: DiagnosticSink,
private val manualVariance: ManualVariance? = null
) {
fun check(c: TopDownAnalysisContext) {
checkClasses(c)
checkMembers(c)
}
fun checkClassOrObject(klass: KtClassOrObject): Boolean {
if (klass is KtClass) {
if (!checkClassHeader(klass)) return false
}
for (member in klass.declarations + klass.getPrimaryConstructorParameters()) {
member as? KtCallableDeclaration ?: continue
val descriptor = when (member) {
is KtParameter -> context.get(BindingContext.PRIMARY_CONSTRUCTOR_PARAMETER, member)
is KtCallableDeclaration -> context.get(BindingContext.DECLARATION_TO_DESCRIPTOR, member)
else -> null
} as? CallableMemberDescriptor ?: continue
if (!checkMember(member, descriptor)) return false
}
return true
}
private fun checkClasses(c: TopDownAnalysisContext) {
for (jetClassOrObject in c.declaredClasses!!.keys) {
if (jetClassOrObject is KtClass) {
checkClassHeader(jetClassOrObject)
}
}
}
private fun checkClassHeader(klass: KtClass): Boolean {
var noError = true
for (specifier in klass.getSuperTypeListEntries()) {
noError = noError and specifier.typeReference?.checkTypePosition(context, OUT_VARIANCE)
}
return noError and klass.checkTypeParameters(context, OUT_VARIANCE)
}
private fun checkMembers(c: TopDownAnalysisContext) {
for ((declaration, descriptor) in c.members) {
checkMember(declaration, descriptor)
}
}
private fun checkMember(member: KtCallableDeclaration, descriptor: CallableMemberDescriptor) =
Visibilities.isPrivate(descriptor.visibility) || checkCallableDeclaration(context, member, descriptor)
private fun TypeParameterDescriptor.varianceWithManual() =
if (manualVariance != null && this == manualVariance.descriptor) manualVariance.variance else variance
fun recordPrivateToThisIfNeeded(descriptor: CallableMemberDescriptor) {
if (isIrrelevant(descriptor) || descriptor.visibility != Visibilities.PRIVATE) return
val psiElement = descriptor.source.getPsi() as? KtCallableDeclaration ?: return
if (!checkCallableDeclaration(context, psiElement, descriptor)) {
recordPrivateToThis(descriptor)
}
}
private fun checkCallableDeclaration(
trace: BindingContext,
declaration: KtCallableDeclaration,
descriptor: CallableDescriptor
): Boolean {
if (isIrrelevant(descriptor)) return true
var noError = true
noError = noError and declaration.checkTypeParameters(trace, IN_VARIANCE)
noError = noError and declaration.receiverTypeReference?.checkTypePosition(trace, IN_VARIANCE)
for (parameter in declaration.valueParameters) {
noError = noError and parameter.typeReference?.checkTypePosition(trace, IN_VARIANCE)
}
val returnTypePosition = if (descriptor is VariableDescriptor && descriptor.isVar) INVARIANT else OUT_VARIANCE
noError = noError and declaration.createTypeBindingForReturnType(trace)?.checkTypePosition(returnTypePosition)
return noError
}
private fun KtTypeParameterListOwner.checkTypeParameters(
trace: BindingContext,
typePosition: Variance
): Boolean {
var noError = true
for (typeParameter in typeParameters) {
noError = noError and typeParameter.extendsBound?.checkTypePosition(trace, typePosition)
}
for (typeConstraint in typeConstraints) {
noError = noError and typeConstraint.boundTypeReference?.checkTypePosition(trace, typePosition)
}
return noError
}
private fun KtTypeReference.checkTypePosition(trace: BindingContext, position: Variance)
= createTypeBinding(trace)?.checkTypePosition(position)
private fun TypeBinding.checkTypePosition(position: Variance) = checkTypePosition(kotlinType, position)
private fun TypeBinding.checkTypePosition(containingType: KotlinType, position: Variance): Boolean {
val classifierDescriptor = kotlinType.constructor.declarationDescriptor
if (classifierDescriptor is TypeParameterDescriptor) {
val declarationVariance = classifierDescriptor.varianceWithManual()
if (!declarationVariance.allowsPosition(position)
&& !kotlinType.annotations.hasAnnotation(KotlinBuiltIns.FQ_NAMES.unsafeVariance)) {
diagnosticSink.report(
Errors.TYPE_VARIANCE_CONFLICT.on(
psiElement,
VarianceConflictDiagnosticData(containingType, classifierDescriptor, position)
)
)
}
return declarationVariance.allowsPosition(position)
}
var noError = true
for (argumentBinding in getArgumentBindings()) {
if (argumentBinding == null || argumentBinding.typeParameterDescriptor == null ||
argumentBinding.typeProjection.isStarProjection) continue
val projectionKind = getEffectiveProjectionKind(argumentBinding.typeParameterDescriptor!!, argumentBinding.typeProjection)!!
val newPosition = when (projectionKind) {
OUT -> position
IN -> position.opposite()
INV -> INVARIANT
STAR -> null // CONFLICTING_PROJECTION error was reported
}
if (newPosition != null) {
noError = noError and argumentBinding.typeBinding.checkTypePosition(containingType, newPosition)
}
}
return noError
}
private fun isIrrelevant(descriptor: CallableDescriptor): Boolean {
val containingClass = descriptor.containingDeclaration as? ClassDescriptor ?: return true
return containingClass.typeConstructor.parameters.all { it.varianceWithManual() == INVARIANT }
}
companion object {
private fun recordPrivateToThis(descriptor: CallableMemberDescriptor) {
when (descriptor) {
is FunctionDescriptorImpl -> descriptor.visibility = Visibilities.PRIVATE_TO_THIS
is PropertyDescriptorImpl -> {
descriptor.visibility = Visibilities.PRIVATE_TO_THIS;
for (accessor in descriptor.accessors) {
(accessor as PropertyAccessorDescriptorImpl).visibility = Visibilities.PRIVATE_TO_THIS
}
}
else -> throw IllegalStateException("Unexpected descriptor type: ${descriptor.javaClass.name}")
}
}
private infix fun Boolean.and(other: Boolean?) = if (other == null) this else this and other
}
}