From 092d10b1a842b27248e2517c1a53aab2d38fdbb6 Mon Sep 17 00:00:00 2001 From: Mikhail Glukhikh Date: Thu, 18 Apr 2019 20:02:31 +0300 Subject: [PATCH] FIR Java: fix creation & handling of type parameter symbols Before this commit, we created type parameter symbols each time when type parameter was referenced or created. In this commit, we introduced class-bound Java type parameter stack and use it to find referenced type parameter symbol. So now they are created only when Java type parameter is created --- .../kotlin/fir/java/JavaSymbolProvider.kt | 88 ++++++++++---- .../kotlin/fir/java/JavaTypeParameterStack.kt | 38 ++++++ .../jetbrains/kotlin/fir/java/JavaUtils.kt | 112 ++++++++++-------- .../fir/java/declarations/FirJavaClass.kt | 6 +- .../enhancement/EnhancementSignatureParts.kt | 12 +- .../fir/java/enhancement/javaTypeUtils.kt | 25 ++-- .../java/scopes/JavaClassEnhancementScope.kt | 16 ++- .../fir/java/scopes/JavaClassUseSiteScope.kt | 10 +- .../kotlin/fir/java/types/FirJavaTypeRef.kt | 2 +- .../compiledJava/ClassWithTypePP.fir.txt | 2 +- .../ClassWithTypePRefNext.fir.txt | 2 +- .../ClassWithTypePRefSelf.fir.txt | 2 +- .../ClassWithTypePRefSelfAndClass.fir.txt | 2 +- .../MethodTypePOneUpperBound.fir.txt | 2 +- .../MethodTypePTwoUpperBounds.fir.txt | 2 +- .../compiledJava/MethodWithTypeP.fir.txt | 2 +- .../compiledJava/MethodWithTypePP.fir.txt | 2 +- .../MethodWithTypePRefClassP.fir.txt | 2 +- .../compiledJava/MethosWithPRefTP.fir.txt | 2 +- .../compiledJava/RawUpperBound.fir.txt | 2 +- .../RecursiveRawUpperBound.fir.txt | 2 +- .../RecursiveWildcardUpperBound.fir.txt | 2 +- .../ConstructorGenericDeep.fir.txt | 2 +- .../ConstructorGenericSimple.fir.txt | 2 +- .../ConstructorGenericUpperBound.fir.txt | 2 +- .../kotlinSignature/AllBoundsInWhen.fir.txt | 2 +- .../ConstructorWithNewTypeParams.fir.txt | 2 +- .../ConstructorWithParentTypeParams.fir.txt | 2 +- .../MethodWithMappedClasses.fir.txt | 4 +- .../MethodWithTypeParameters.fir.txt | 2 +- .../WrongTypeParameterBoundStructure1.fir.txt | 2 +- .../loadJava/compiledJava/library/Max.fir.txt | 2 +- .../LoadIterableWithNullability.fir.txt | 8 +- ...ricInterfaceParameterWithSelfBound.fir.txt | 2 +- ...nericInterfaceParametersWithBounds.fir.txt | 2 +- .../sam/GenericMethodParameters.fir.txt | 2 +- .../adapters/TypeParameterOfMethod.fir.txt | 6 +- .../static/StaticMembersInEnum.fir.txt | 2 +- 38 files changed, 249 insertions(+), 130 deletions(-) create mode 100644 compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaTypeParameterStack.kt diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaSymbolProvider.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaSymbolProvider.kt index f1f5c1c21a8..62ded07fd9e 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaSymbolProvider.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaSymbolProvider.kt @@ -9,6 +9,8 @@ import com.intellij.openapi.project.Project import com.intellij.psi.search.GlobalSearchScope import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.declarations.FirRegularClass +import org.jetbrains.kotlin.fir.declarations.FirTypeParameter +import org.jetbrains.kotlin.fir.declarations.impl.FirTypeParameterImpl import org.jetbrains.kotlin.fir.java.declarations.FirJavaClass import org.jetbrains.kotlin.fir.java.declarations.FirJavaConstructor import org.jetbrains.kotlin.fir.java.declarations.FirJavaField @@ -26,16 +28,19 @@ import org.jetbrains.kotlin.fir.symbols.ConeClassLikeSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirFieldSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol import org.jetbrains.kotlin.fir.types.ConeClassErrorType import org.jetbrains.kotlin.fir.types.impl.ConeTypeParameterTypeImpl import org.jetbrains.kotlin.fir.types.impl.FirResolvedTypeRefImpl import org.jetbrains.kotlin.load.java.JavaClassFinder import org.jetbrains.kotlin.load.java.JvmAnnotationNames import org.jetbrains.kotlin.load.java.structure.JavaClass +import org.jetbrains.kotlin.load.java.structure.JavaTypeParameter import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.resolve.jvm.KotlinJavaPsiFacade +import org.jetbrains.kotlin.types.Variance.INVARIANT class JavaSymbolProvider( val session: FirSession, @@ -98,6 +103,35 @@ class JavaSymbolProvider( } } + private fun JavaTypeParameter.toFirTypeParameter(javaTypeParameterStack: JavaTypeParameterStack): FirTypeParameter { + val stored = javaTypeParameterStack.safeGet(this) + if (stored != null) return stored.fir + val firSymbol = FirTypeParameterSymbol() + val result = FirTypeParameterImpl(session, null, firSymbol, name, variance = INVARIANT, isReified = false) + javaTypeParameterStack.add(this, result) + return result + } + + private fun FirTypeParameter.addBounds( + javaTypeParameter: JavaTypeParameter, + stack: JavaTypeParameterStack + ) { + require(this is FirTypeParameterImpl) + for (upperBound in javaTypeParameter.upperBounds) { + bounds += upperBound.toFirResolvedTypeRef(this@JavaSymbolProvider.session, stack) + } + } + + private fun List.convertTypeParameters(stack: JavaTypeParameterStack): List { + return this + .map { it.toFirTypeParameter(stack) } + .also { + it.forEachIndexed { index, typeParameter -> + typeParameter.addBounds(this[index], stack) + } + } + } + override fun getClassLikeSymbolByFqName(classId: ClassId): ConeClassLikeSymbol? { if (!hasTopLevelClassOf(classId)) return null return classCache.lookupCacheOrCalculateWithPostCompute(classId, { @@ -109,18 +143,28 @@ class JavaSymbolProvider( } }) { firSymbol, foundClass -> foundClass?.let { javaClass -> + val javaTypeParameterStack = JavaTypeParameterStack() + val parentFqName = classId.relativeClassName.parent() + val isTopLevel = parentFqName.isRoot + if (!isTopLevel) { + val parentId = ClassId(classId.packageFqName, parentFqName, false) + val parentClassSymbol = getClassLikeSymbolByFqName(parentId) as? FirClassSymbol + val parentClass = parentClassSymbol?.fir + if (parentClass is FirJavaClass) { + javaTypeParameterStack.addStack(parentClass.javaTypeParameterStack) + } + } FirJavaClass( session, firSymbol as FirClassSymbol, javaClass.name, javaClass.visibility, javaClass.modality, - javaClass.classKind, - isTopLevel = classId.relativeClassName.parent().isRoot, isStatic = javaClass.isStatic + javaClass.classKind, isTopLevel = isTopLevel, + isStatic = javaClass.isStatic, + javaTypeParameterStack = javaTypeParameterStack ).apply { - for (typeParameter in javaClass.typeParameters) { - typeParameters += createTypeParameterSymbol(this@JavaSymbolProvider.session, typeParameter.name).fir - } - addAnnotationsFrom(this@JavaSymbolProvider.session, javaClass) + this.typeParameters += foundClass.typeParameters.convertTypeParameters(javaTypeParameterStack) + addAnnotationsFrom(this@JavaSymbolProvider.session, javaClass, javaTypeParameterStack) for (supertype in javaClass.supertypes) { - superTypeRefs += supertype.toFirResolvedTypeRef(this@JavaSymbolProvider.session) + superTypeRefs += supertype.toFirResolvedTypeRef(this@JavaSymbolProvider.session, javaTypeParameterStack) } // TODO: may be we can process fields & methods later. // However, they should be built up to override resolve stage @@ -132,11 +176,11 @@ class JavaSymbolProvider( val firJavaField = FirJavaField( this@JavaSymbolProvider.session, fieldSymbol, fieldName, javaField.visibility, javaField.modality, - returnTypeRef = returnType.toFirJavaTypeRef(this@JavaSymbolProvider.session), + returnTypeRef = returnType.toFirJavaTypeRef(this@JavaSymbolProvider.session, javaTypeParameterStack), isVar = !javaField.isFinal, isStatic = javaField.isStatic ).apply { - addAnnotationsFrom(this@JavaSymbolProvider.session, javaField) + addAnnotationsFrom(this@JavaSymbolProvider.session, javaField, javaTypeParameterStack) } declarations += firJavaField } @@ -148,15 +192,15 @@ class JavaSymbolProvider( val firJavaMethod = FirJavaMethod( this@JavaSymbolProvider.session, methodSymbol, methodName, javaMethod.visibility, javaMethod.modality, - returnTypeRef = returnType.toFirJavaTypeRef(this@JavaSymbolProvider.session), + returnTypeRef = returnType.toFirJavaTypeRef(this@JavaSymbolProvider.session, javaTypeParameterStack), isStatic = javaMethod.isStatic ).apply { - for (typeParameter in javaMethod.typeParameters) { - typeParameters += createTypeParameterSymbol(this@JavaSymbolProvider.session, typeParameter.name).fir - } - addAnnotationsFrom(this@JavaSymbolProvider.session, javaMethod) + this.typeParameters += javaMethod.typeParameters.convertTypeParameters(javaTypeParameterStack) + addAnnotationsFrom(this@JavaSymbolProvider.session, javaMethod, javaTypeParameterStack) for (valueParameter in javaMethod.valueParameters) { - valueParameters += valueParameter.toFirValueParameters(this@JavaSymbolProvider.session) + valueParameters += valueParameter.toFirValueParameters( + this@JavaSymbolProvider.session, javaTypeParameterStack + ) } } declarations += firJavaMethod @@ -164,12 +208,8 @@ class JavaSymbolProvider( for (javaConstructor in javaClass.constructors) { val constructorId = CallableId(classId.packageFqName, classId.relativeClassName, classId.shortClassName) val constructorSymbol = FirFunctionSymbol(constructorId) - val classTypeParameters = typeParameters.map { - createTypeParameterSymbol(this@JavaSymbolProvider.session, it.name).fir - } - val constructorTypeParameters = javaConstructor.typeParameters.map { - createTypeParameterSymbol(this@JavaSymbolProvider.session, it.name).fir - } + val classTypeParameters = javaClass.typeParameters.convertTypeParameters(javaTypeParameterStack) + val constructorTypeParameters = javaConstructor.typeParameters.convertTypeParameters(javaTypeParameterStack) val typeParameters = classTypeParameters + constructorTypeParameters val firJavaConstructor = FirJavaConstructor( this@JavaSymbolProvider.session, constructorSymbol, javaConstructor.visibility, @@ -182,9 +222,11 @@ class JavaSymbolProvider( ) ).apply { this.typeParameters += typeParameters - addAnnotationsFrom(this@JavaSymbolProvider.session, javaConstructor) + addAnnotationsFrom(this@JavaSymbolProvider.session, javaConstructor, javaTypeParameterStack) for (valueParameter in javaConstructor.valueParameters) { - valueParameters += valueParameter.toFirValueParameters(this@JavaSymbolProvider.session) + valueParameters += valueParameter.toFirValueParameters( + this@JavaSymbolProvider.session, javaTypeParameterStack + ) } } declarations += firJavaConstructor diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaTypeParameterStack.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaTypeParameterStack.kt new file mode 100644 index 00000000000..e894c37d1f3 --- /dev/null +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaTypeParameterStack.kt @@ -0,0 +1,38 @@ +/* + * Copyright 2010-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license + * that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.fir.java + +import org.jetbrains.kotlin.fir.declarations.FirTypeParameter +import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol +import org.jetbrains.kotlin.load.java.structure.JavaTypeParameter + +internal class JavaTypeParameterStack { + + private val typeParameterMap = mutableMapOf() + + fun add(javaTypeParameter: JavaTypeParameter, firTypeParameter: FirTypeParameter) { + typeParameterMap[javaTypeParameter] = firTypeParameter.symbol + } + + fun addStack(javaTypeParameterStack: JavaTypeParameterStack) { + typeParameterMap += javaTypeParameterStack.typeParameterMap + } + + fun remove(javaTypeParameter: JavaTypeParameter) { + typeParameterMap.remove(javaTypeParameter) + } + + operator fun get(javaTypeParameter: JavaTypeParameter): FirTypeParameterSymbol { + return safeGet(javaTypeParameter) + ?: throw IllegalArgumentException("Cannot find Java type parameter $javaTypeParameter in stack") + } + + fun safeGet(javaTypeParameter: JavaTypeParameter) = typeParameterMap[javaTypeParameter] + + companion object { + val EMPTY: JavaTypeParameterStack = JavaTypeParameterStack() + } +} \ No newline at end of file diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaUtils.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaUtils.kt index 0675e0d0a9a..424c0734840 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaUtils.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaUtils.kt @@ -10,7 +10,6 @@ import org.jetbrains.kotlin.descriptors.Modality import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.declarations.FirTypeParameter import org.jetbrains.kotlin.fir.declarations.FirValueParameter -import org.jetbrains.kotlin.fir.declarations.impl.FirTypeParameterImpl import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirArrayOfCall import org.jetbrains.kotlin.fir.expressions.FirExpression @@ -26,7 +25,6 @@ import org.jetbrains.kotlin.fir.service import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTagImpl import org.jetbrains.kotlin.fir.symbols.StandardClassIds import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol -import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.fir.types.impl.ConeClassTypeImpl import org.jetbrains.kotlin.fir.types.impl.ConeTypeParameterTypeImpl @@ -34,7 +32,6 @@ import org.jetbrains.kotlin.fir.types.impl.FirResolvedTypeRefImpl import org.jetbrains.kotlin.ir.expressions.IrConstKind import org.jetbrains.kotlin.load.java.structure.* import org.jetbrains.kotlin.name.ClassId -import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.types.Variance.* @@ -61,37 +58,48 @@ internal fun ClassId.toConeKotlinType( return ConeClassTypeImpl(lookupTag, typeArguments, isNullable) } -internal fun FirTypeRef.toNotNullConeKotlinType(session: FirSession): ConeKotlinType = +internal fun FirTypeRef.toNotNullConeKotlinType( + session: FirSession, javaTypeParameterStack: JavaTypeParameterStack +): ConeKotlinType = when (this) { is FirResolvedTypeRef -> type is FirJavaTypeRef -> { val javaType = type - javaType.toNotNullConeKotlinType(session) + javaType.toNotNullConeKotlinType(session, javaTypeParameterStack) } else -> ConeKotlinErrorType("Unexpected type reference in JavaClassUseSiteScope: ${this::class.java}") } -internal fun JavaType?.toNotNullConeKotlinType(session: FirSession): ConeLookupTagBasedType { - return toConeKotlinTypeWithNullability(session, isNullable = false) +internal fun JavaType?.toNotNullConeKotlinType( + session: FirSession, javaTypeParameterStack: JavaTypeParameterStack +): ConeLookupTagBasedType { + return toConeKotlinTypeWithNullability(session, javaTypeParameterStack, isNullable = false) } -internal fun JavaType.toFirJavaTypeRef(session: FirSession): FirJavaTypeRef { +internal fun JavaType.toFirJavaTypeRef(session: FirSession, javaTypeParameterStack: JavaTypeParameterStack): FirJavaTypeRef { val annotations = (this as? JavaClassifierType)?.annotations.orEmpty() - return FirJavaTypeRef(session, annotations = annotations.map { it.toFirAnnotationCall(session) }, type = this) -} - -internal fun JavaClassifierType.toFirResolvedTypeRef(session: FirSession): FirResolvedTypeRef { - val coneType = this.toConeKotlinTypeWithNullability(session, isNullable = false) - return FirResolvedTypeRefImpl( - session, psi = null, type = coneType, - isMarkedNullable = false, annotations = annotations.map { it.toFirAnnotationCall(session) } + return FirJavaTypeRef( + session, + annotations = annotations.map { it.toFirAnnotationCall(session, javaTypeParameterStack) }, type = this ) } -internal fun JavaType?.toConeKotlinTypeWithNullability(session: FirSession, isNullable: Boolean): ConeLookupTagBasedType { +internal fun JavaClassifierType.toFirResolvedTypeRef( + session: FirSession, javaTypeParameterStack: JavaTypeParameterStack +): FirResolvedTypeRef { + val coneType = this.toConeKotlinTypeWithNullability(session, javaTypeParameterStack, isNullable = false) + return FirResolvedTypeRefImpl( + session, psi = null, type = coneType, isMarkedNullable = false, + annotations = annotations.map { it.toFirAnnotationCall(session, javaTypeParameterStack) } + ) +} + +internal fun JavaType?.toConeKotlinTypeWithNullability( + session: FirSession, javaTypeParameterStack: JavaTypeParameterStack, isNullable: Boolean +): ConeLookupTagBasedType { return when (this) { is JavaClassifierType -> { - toConeKotlinTypeWithNullability(session, isNullable) + toConeKotlinTypeWithNullability(session, isNullable, javaTypeParameterStack) } is JavaPrimitiveType -> { val primitiveType = type @@ -107,8 +115,8 @@ internal fun JavaType?.toConeKotlinTypeWithNullability(session: FirSession, isNu if (componentType !is JavaPrimitiveType) { val classId = StandardClassIds.Array val argumentType = ConeFlexibleType( - componentType.toConeKotlinTypeWithNullability(session, isNullable = false), - componentType.toConeKotlinTypeWithNullability(session, isNullable = true) + componentType.toConeKotlinTypeWithNullability(session, javaTypeParameterStack, isNullable = false), + componentType.toConeKotlinTypeWithNullability(session, javaTypeParameterStack, isNullable = true) ) classId.toConeKotlinType(arrayOf(argumentType), isNullable) } else { @@ -117,7 +125,7 @@ internal fun JavaType?.toConeKotlinTypeWithNullability(session: FirSession, isNu classId.toConeKotlinType(emptyArray(), isNullable) } } - is JavaWildcardType -> bound?.toNotNullConeKotlinType(session) ?: run { + is JavaWildcardType -> bound?.toNotNullConeKotlinType(session, javaTypeParameterStack) ?: run { val classId = StandardClassIds.Any classId.toConeKotlinType(emptyArray(), isNullable) } @@ -129,7 +137,9 @@ internal fun JavaType?.toConeKotlinTypeWithNullability(session: FirSession, isNu } } -internal fun JavaClassifierType.toConeKotlinTypeWithNullability(session: FirSession, isNullable: Boolean): ConeLookupTagBasedType { +internal fun JavaClassifierType.toConeKotlinTypeWithNullability( + session: FirSession, isNullable: Boolean, javaTypeParameterStack: JavaTypeParameterStack +): ConeLookupTagBasedType { return when (val classifier = classifier) { is JavaClass -> { val classId = classifier.classId!! @@ -137,29 +147,23 @@ internal fun JavaClassifierType.toConeKotlinTypeWithNullability(session: FirSess lookupTag.constructClassType( typeArguments.mapIndexed { index, argument -> argument.toConeProjection( - session, null + session, javaTypeParameterStack, null //symbol.fir.typeParameters.getOrNull(index) ) }.toTypedArray(), isNullable ) } is JavaTypeParameter -> { - // TODO: it's unclear how to identify type parameter by the symbol - // TODO: some type parameter cache (provider?) - val symbol = createTypeParameterSymbol(session, classifier.name) + val symbol = javaTypeParameterStack[classifier] ConeTypeParameterTypeImpl(symbol, isNullable) } else -> ConeClassErrorType(reason = "Unexpected classifier: $classifier") } } -internal fun createTypeParameterSymbol(session: FirSession, name: Name): FirTypeParameterSymbol { - val firSymbol = FirTypeParameterSymbol() - FirTypeParameterImpl(session, null, firSymbol, name, variance = INVARIANT, isReified = false) - return firSymbol -} - -internal fun JavaAnnotation.toFirAnnotationCall(session: FirSession): FirAnnotationCall { +internal fun JavaAnnotation.toFirAnnotationCall( + session: FirSession, javaTypeParameterStack: JavaTypeParameterStack +): FirAnnotationCall { return FirAnnotationCallImpl( session, psi = null, useSiteTarget = null, annotationTypeRef = FirResolvedTypeRefImpl( @@ -171,28 +175,34 @@ internal fun JavaAnnotation.toFirAnnotationCall(session: FirSession): FirAnnotat ) ).apply { for (argument in this@toFirAnnotationCall.arguments) { - arguments += argument.toFirExpression(session) + arguments += argument.toFirExpression(session, javaTypeParameterStack) } } } -internal fun FirAbstractAnnotatedElement.addAnnotationsFrom(session: FirSession, javaAnnotationOwner: JavaAnnotationOwner) { +internal fun FirAbstractAnnotatedElement.addAnnotationsFrom( + session: FirSession, javaAnnotationOwner: JavaAnnotationOwner, javaTypeParameterStack: JavaTypeParameterStack +) { for (annotation in javaAnnotationOwner.annotations) { - annotations += annotation.toFirAnnotationCall(session) + annotations += annotation.toFirAnnotationCall(session, javaTypeParameterStack) } } -internal fun JavaValueParameter.toFirValueParameters(session: FirSession): FirValueParameter { +internal fun JavaValueParameter.toFirValueParameters( + session: FirSession, javaTypeParameterStack: JavaTypeParameterStack +): FirValueParameter { return FirJavaValueParameter( session, name ?: Name.special(""), - returnTypeRef = type.toFirJavaTypeRef(session), + returnTypeRef = type.toFirJavaTypeRef(session, javaTypeParameterStack), isVararg = isVararg ).apply { - addAnnotationsFrom(session, this@toFirValueParameters) + addAnnotationsFrom(session, this@toFirValueParameters, javaTypeParameterStack) } } -internal fun JavaType?.toConeProjection(session: FirSession, boundTypeParameter: FirTypeParameter?): ConeKotlinTypeProjection { +internal fun JavaType?.toConeProjection( + session: FirSession, javaTypeParameterStack: JavaTypeParameterStack, boundTypeParameter: FirTypeParameter? +): ConeKotlinTypeProjection { return when (this) { null -> ConeStarProjection is JavaWildcardType -> { @@ -202,7 +212,7 @@ internal fun JavaType?.toConeProjection(session: FirSession, boundTypeParameter: if (bound == null || parameterVariance != INVARIANT && parameterVariance != argumentVariance) { ConeStarProjection } else { - val boundType = bound.toConeKotlinTypeWithNullability(session, isNullable = false) + val boundType = bound.toConeKotlinTypeWithNullability(session, javaTypeParameterStack, isNullable = false) if (argumentVariance == OUT_VARIANCE) { ConeKotlinTypeProjectionOut(boundType) } else { @@ -210,12 +220,14 @@ internal fun JavaType?.toConeProjection(session: FirSession, boundTypeParameter: } } } - is JavaClassifierType -> toConeKotlinTypeWithNullability(session, isNullable = false) + is JavaClassifierType -> toConeKotlinTypeWithNullability(session, javaTypeParameterStack, isNullable = false) else -> ConeClassErrorType("Unexpected type argument: $this") } } -private fun JavaAnnotationArgument.toFirExpression(session: FirSession): FirExpression { +private fun JavaAnnotationArgument.toFirExpression( + session: FirSession, javaTypeParameterStack: JavaTypeParameterStack +): FirExpression { // TODO: this.name return when (this) { is JavaLiteralAnnotationArgument -> { @@ -233,7 +245,7 @@ private fun JavaAnnotationArgument.toFirExpression(session: FirSession): FirExpr } is JavaArrayAnnotationArgument -> FirArrayOfCallImpl(session, null).apply { for (element in getElements()) { - arguments += element.toFirExpression(session) + arguments += element.toFirExpression(session, javaTypeParameterStack) } } is JavaEnumValueAnnotationArgument -> { @@ -256,9 +268,11 @@ private fun JavaAnnotationArgument.toFirExpression(session: FirSession): FirExpr } is JavaClassObjectAnnotationArgument -> FirGetClassCallImpl(session, null).apply { val referencedType = getReferencedType() - arguments += FirClassReferenceExpressionImpl(session, null, referencedType.toFirResolvedTypeRef(session)) + arguments += FirClassReferenceExpressionImpl( + session, null, referencedType.toFirResolvedTypeRef(session, javaTypeParameterStack) + ) } - is JavaAnnotationAsAnnotationArgument -> getAnnotation().toFirAnnotationCall(session) + is JavaAnnotationAsAnnotationArgument -> getAnnotation().toFirAnnotationCall(session, javaTypeParameterStack) else -> FirErrorExpressionImpl(session, null, "Unknown JavaAnnotationArgument: ${this::class.java}") } } @@ -289,8 +303,10 @@ private fun Any?.createConstant(session: FirSession): FirExpression { } } -private fun JavaType.toFirResolvedTypeRef(session: FirSession): FirResolvedTypeRef { - if (this is JavaClassifierType) return toFirResolvedTypeRef(session) +private fun JavaType.toFirResolvedTypeRef( + session: FirSession, javaTypeParameterStack: JavaTypeParameterStack +): FirResolvedTypeRef { + if (this is JavaClassifierType) return toFirResolvedTypeRef(session, javaTypeParameterStack) return FirResolvedTypeRefImpl( session, psi = null, type = ConeClassErrorType("Unexpected JavaType: $this"), isMarkedNullable = false, annotations = emptyList() diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/declarations/FirJavaClass.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/declarations/FirJavaClass.kt index da4d2003ce0..1238778ea09 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/declarations/FirJavaClass.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/declarations/FirJavaClass.kt @@ -13,11 +13,12 @@ import org.jetbrains.kotlin.fir.declarations.FirDeclaration import org.jetbrains.kotlin.fir.declarations.FirRegularClass import org.jetbrains.kotlin.fir.declarations.impl.FirAbstractMemberDeclaration import org.jetbrains.kotlin.fir.declarations.impl.FirModifiableClass +import org.jetbrains.kotlin.fir.java.JavaTypeParameterStack import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.name.Name -class FirJavaClass( +class FirJavaClass internal constructor( session: FirSession, override val symbol: FirClassSymbol, name: Name, @@ -25,7 +26,8 @@ class FirJavaClass( modality: Modality?, override val classKind: ClassKind, isTopLevel: Boolean, - isStatic: Boolean + isStatic: Boolean, + internal val javaTypeParameterStack: JavaTypeParameterStack ) : FirAbstractMemberDeclaration( session, psi = null, name = name, visibility = visibility, modality = modality, diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/EnhancementSignatureParts.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/EnhancementSignatureParts.kt index e368617110c..bcb11d93163 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/EnhancementSignatureParts.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/EnhancementSignatureParts.kt @@ -11,6 +11,7 @@ import org.jetbrains.kotlin.fir.declarations.FirValueParameter import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirAnnotationContainer import org.jetbrains.kotlin.fir.expressions.resolvedFqName +import org.jetbrains.kotlin.fir.java.JavaTypeParameterStack import org.jetbrains.kotlin.fir.java.toConeKotlinTypeWithNullability import org.jetbrains.kotlin.fir.java.toFirJavaTypeRef import org.jetbrains.kotlin.fir.java.toNotNullConeKotlinType @@ -30,6 +31,7 @@ import org.jetbrains.kotlin.utils.addToStdlib.safeAs internal class EnhancementSignatureParts( private val typeQualifierResolver: FirAnnotationTypeQualifierResolver, private val typeContainer: FirAnnotationContainer?, + private val javaTypeParameterStack: JavaTypeParameterStack, private val current: FirJavaTypeRef, private val fromOverridden: Collection, private val isCovariant: Boolean, @@ -54,7 +56,7 @@ internal class EnhancementSignatureParts( } } - val containsFunctionN = current.toNotNullConeKotlinType(session).contains { + val containsFunctionN = current.toNotNullConeKotlinType(session, javaTypeParameterStack).contains { if (it is ConeClassErrorType) false else { val classId = it.lookupTag.classId @@ -63,7 +65,7 @@ internal class EnhancementSignatureParts( } } - val enhancedCurrent = current.enhance(session, qualifiersWithPredefined ?: qualifiers) + val enhancedCurrent = current.enhance(session, javaTypeParameterStack, qualifiersWithPredefined ?: qualifiers) return PartEnhancementResult( enhancedCurrent, wereChanges = true, containsFunctionN = containsFunctionN ) @@ -100,7 +102,7 @@ internal class EnhancementSignatureParts( if (arg is JavaWildcardType || arg == null) { add(null) } else { - add(arg.toFirJavaTypeRef(context.session)) + add(arg.toFirJavaTypeRef(context.session, javaTypeParameterStack)) } } } else if (type != null) { @@ -148,8 +150,8 @@ internal class EnhancementSignatureParts( is FirJavaTypeRef -> { Pair( // TODO: optimize - type.toConeKotlinTypeWithNullability(session, isNullable = false), - type.toConeKotlinTypeWithNullability(session, isNullable = true) + type.toConeKotlinTypeWithNullability(session, javaTypeParameterStack, isNullable = false), + type.toConeKotlinTypeWithNullability(session, javaTypeParameterStack, isNullable = true) ) } else -> return JavaTypeQualifiers.NONE diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/javaTypeUtils.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/javaTypeUtils.kt index c13c1e3a492..942cbbb92b2 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/javaTypeUtils.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/javaTypeUtils.kt @@ -13,7 +13,7 @@ import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.expressions.* import org.jetbrains.kotlin.fir.expressions.impl.FirConstExpressionImpl import org.jetbrains.kotlin.fir.expressions.impl.FirQualifiedAccessExpressionImpl -import org.jetbrains.kotlin.fir.java.createTypeParameterSymbol +import org.jetbrains.kotlin.fir.java.JavaTypeParameterStack import org.jetbrains.kotlin.fir.java.declarations.FirJavaClass import org.jetbrains.kotlin.fir.java.declarations.FirJavaField import org.jetbrains.kotlin.fir.java.toConeProjection @@ -51,8 +51,12 @@ internal class IndexedJavaTypeQualifiers(private val data: Array..C)` gives `0 - (A..C), 1 - B and D`. private fun JavaType?.enhancePossiblyFlexible( session: FirSession, + javaTypeParameterStack: JavaTypeParameterStack, annotations: List, qualifiers: IndexedJavaTypeQualifiers, index: Int @@ -70,10 +75,10 @@ private fun JavaType?.enhancePossiblyFlexible( return when (type) { is JavaClassifierType -> { val lowerResult = type.enhanceInflexibleType( - session, annotations, arguments, TypeComponentPosition.FLEXIBLE_LOWER, qualifiers, index + session, javaTypeParameterStack, annotations, arguments, TypeComponentPosition.FLEXIBLE_LOWER, qualifiers, index ) val upperResult = type.enhanceInflexibleType( - session, annotations, arguments, TypeComponentPosition.FLEXIBLE_UPPER, qualifiers, index + session, javaTypeParameterStack, annotations, arguments, TypeComponentPosition.FLEXIBLE_UPPER, qualifiers, index ) FirResolvedTypeRefImpl( @@ -83,7 +88,7 @@ private fun JavaType?.enhancePossiblyFlexible( ) } else -> { - val enhanced = type.toNotNullConeKotlinType(session) + val enhanced = type.toNotNullConeKotlinType(session, javaTypeParameterStack) FirResolvedTypeRefImpl(session, psi = null, type = enhanced, isMarkedNullable = false, annotations = annotations) } } @@ -125,6 +130,7 @@ private fun ClassId.mutableToReadOnly(): ClassId? { private fun JavaClassifierType.enhanceInflexibleType( session: FirSession, + javaTypeParameterStack: JavaTypeParameterStack, annotations: List, arguments: List, position: TypeComponentPosition, @@ -143,8 +149,8 @@ private fun JavaClassifierType.enhanceInflexibleType( val kotlinClassId = mappedId ?: classId ConeClassLikeLookupTagImpl(kotlinClassId) } - is JavaTypeParameter -> createTypeParameterSymbol(session, classifier.name) - else -> return toNotNullConeKotlinType(session) + is JavaTypeParameter -> javaTypeParameterStack[classifier] + else -> return toNotNullConeKotlinType(session, javaTypeParameterStack) } val effectiveQualifiers = qualifiers(index) @@ -156,10 +162,11 @@ private fun JavaClassifierType.enhanceInflexibleType( globalArgIndex++ arg.toConeProjection( session, + javaTypeParameterStack, ((originalTag as? FirBasedSymbol<*>)?.fir as? FirCallableMemberDeclaration)?.typeParameters?.getOrNull(localArgIndex) ) } else { - val argEnhancedTypeRef = arg.enhancePossiblyFlexible(session, annotations, qualifiers, globalArgIndex) + val argEnhancedTypeRef = arg.enhancePossiblyFlexible(session, javaTypeParameterStack, annotations, qualifiers, globalArgIndex) globalArgIndex += arg.subtreeSize() argEnhancedTypeRef.type.type.toTypeProjection(Variance.INVARIANT) } diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/scopes/JavaClassEnhancementScope.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/scopes/JavaClassEnhancementScope.kt index 63b881a1b23..88b6f58838c 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/scopes/JavaClassEnhancementScope.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/scopes/JavaClassEnhancementScope.kt @@ -11,10 +11,8 @@ import org.jetbrains.kotlin.fir.declarations.impl.* import org.jetbrains.kotlin.fir.expressions.FirAnnotationContainer import org.jetbrains.kotlin.fir.expressions.FirExpression import org.jetbrains.kotlin.fir.expressions.impl.FirConstExpressionImpl -import org.jetbrains.kotlin.fir.java.declarations.FirJavaConstructor -import org.jetbrains.kotlin.fir.java.declarations.FirJavaField -import org.jetbrains.kotlin.fir.java.declarations.FirJavaMethod -import org.jetbrains.kotlin.fir.java.declarations.FirJavaValueParameter +import org.jetbrains.kotlin.fir.java.JavaTypeParameterStack +import org.jetbrains.kotlin.fir.java.declarations.* import org.jetbrains.kotlin.fir.java.enhancement.* import org.jetbrains.kotlin.fir.java.enhancement.EnhancementSignatureParts import org.jetbrains.kotlin.fir.java.toNotNullConeKotlinType @@ -42,7 +40,10 @@ class JavaClassEnhancementScope( private val session: FirSession, private val useSiteScope: JavaClassUseSiteScope ) : FirScope { - private val owner: FirRegularClass get() = useSiteScope.symbol.fir + private val owner: FirRegularClass = useSiteScope.symbol.fir + + private val javaTypeParameterStack: JavaTypeParameterStack = + if (owner is FirJavaClass) owner.javaTypeParameterStack else JavaTypeParameterStack.EMPTY private val jsr305State: Jsr305State = session.jsr305State ?: Jsr305State.DEFAULT @@ -188,12 +189,14 @@ class JavaClassEnhancementScope( newReceiverTypeRef, newReturnTypeRef ).apply { this.valueParameters += newValueParameters + this.typeParameters += firMethod.typeParameters } else -> FirMemberFunctionImpl( this@JavaClassEnhancementScope.session, null, symbol, name, newReceiverTypeRef, newReturnTypeRef ).apply { this.valueParameters += newValueParameters + this.typeParameters += firMethod.typeParameters } } function.apply { @@ -226,7 +229,7 @@ class JavaClassEnhancementScope( private fun StringBuilder.appendErasedType(typeRef: FirTypeRef) { when (typeRef) { is FirResolvedTypeRef -> appendConeType(typeRef.type) - is FirJavaTypeRef -> appendConeType(typeRef.toNotNullConeKotlinType(session)) + is FirJavaTypeRef -> appendConeType(typeRef.toNotNullConeKotlinType(session, javaTypeParameterStack)) } } @@ -390,6 +393,7 @@ class JavaClassEnhancementScope( return EnhancementSignatureParts( typeQualifierResolver, typeContainer, + javaTypeParameterStack, typeRef as FirJavaTypeRef, overriddenMembers.map { typeInSignature.getTypeRef(it) diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/scopes/JavaClassUseSiteScope.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/scopes/JavaClassUseSiteScope.kt index b781469c633..a0df09cda41 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/scopes/JavaClassUseSiteScope.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/scopes/JavaClassUseSiteScope.kt @@ -9,6 +9,8 @@ import org.jetbrains.kotlin.builtins.jvm.JavaToKotlinClassMap import org.jetbrains.kotlin.descriptors.Modality import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.declarations.* +import org.jetbrains.kotlin.fir.java.JavaTypeParameterStack +import org.jetbrains.kotlin.fir.java.declarations.FirJavaClass import org.jetbrains.kotlin.fir.java.toNotNullConeKotlinType import org.jetbrains.kotlin.fir.resolve.transformers.firUnsafe import org.jetbrains.kotlin.fir.scopes.FirScope @@ -33,6 +35,9 @@ class JavaClassUseSiteScope( ) : FirAbstractProviderBasedScope(session, lookupInFir = true) { internal val symbol = klass.symbol + private val javaTypeParameterStack: JavaTypeParameterStack = + if (klass is FirJavaClass) klass.javaTypeParameterStack else JavaTypeParameterStack.EMPTY + //base symbol as key, overridden as value private val overriddenByBase = mutableMapOf() @@ -54,7 +59,10 @@ class JavaClassUseSiteScope( } private fun isEqualTypes(a: FirTypeRef, b: FirTypeRef) = - isEqualTypes(a.toNotNullConeKotlinType(session), b.toNotNullConeKotlinType(session)) + isEqualTypes( + a.toNotNullConeKotlinType(session, javaTypeParameterStack), + b.toNotNullConeKotlinType(session, javaTypeParameterStack) + ) private fun isOverriddenFunCheck(overriddenInJava: FirFunction, base: FirFunction): Boolean { val receiverTypeRef = (base as FirCallableMemberDeclaration).receiverTypeRef diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/types/FirJavaTypeRef.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/types/FirJavaTypeRef.kt index c4e06825445..cc3a36dba22 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/types/FirJavaTypeRef.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/types/FirJavaTypeRef.kt @@ -14,7 +14,7 @@ class FirJavaTypeRef( session: FirSession, annotations: List, val type: JavaType -) : FirUserTypeRefImpl(session, psi = null,isMarkedNullable = false) { +) : FirUserTypeRefImpl(session, psi = null, isMarkedNullable = false) { init { this.annotations += annotations } diff --git a/compiler/testData/loadJava/compiledJava/ClassWithTypePP.fir.txt b/compiler/testData/loadJava/compiledJava/ClassWithTypePP.fir.txt index 3e030fe0053..e956660f7b8 100644 --- a/compiler/testData/loadJava/compiledJava/ClassWithTypePP.fir.txt +++ b/compiler/testData/loadJava/compiledJava/ClassWithTypePP.fir.txt @@ -1,2 +1,2 @@ -public final class ClassWithTypePP : R|java/lang/Object| { +public final class ClassWithTypePP : R|java/lang/Object| { } diff --git a/compiler/testData/loadJava/compiledJava/ClassWithTypePRefNext.fir.txt b/compiler/testData/loadJava/compiledJava/ClassWithTypePRefNext.fir.txt index 218e83bf416..2f7fc5d9842 100644 --- a/compiler/testData/loadJava/compiledJava/ClassWithTypePRefNext.fir.txt +++ b/compiler/testData/loadJava/compiledJava/ClassWithTypePRefNext.fir.txt @@ -1,2 +1,2 @@ -public open class ClassWithTypePRefNext : R|java/lang/Object| { +public open class ClassWithTypePRefNext|, P> : R|java/lang/Object| { } diff --git a/compiler/testData/loadJava/compiledJava/ClassWithTypePRefSelf.fir.txt b/compiler/testData/loadJava/compiledJava/ClassWithTypePRefSelf.fir.txt index 11a5b7541a9..e73c3394292 100644 --- a/compiler/testData/loadJava/compiledJava/ClassWithTypePRefSelf.fir.txt +++ b/compiler/testData/loadJava/compiledJava/ClassWithTypePRefSelf.fir.txt @@ -1,2 +1,2 @@ -public final class ClassWithTypePRefSelf

: R|java/lang/Object| { +public final class ClassWithTypePRefSelf

|> : R|java/lang/Object| { } diff --git a/compiler/testData/loadJava/compiledJava/ClassWithTypePRefSelfAndClass.fir.txt b/compiler/testData/loadJava/compiledJava/ClassWithTypePRefSelfAndClass.fir.txt index b1b96d2e6a2..9fb3cc0c5f2 100644 --- a/compiler/testData/loadJava/compiledJava/ClassWithTypePRefSelfAndClass.fir.txt +++ b/compiler/testData/loadJava/compiledJava/ClassWithTypePRefSelfAndClass.fir.txt @@ -1,2 +1,2 @@ -public final class ClassWithTypePRefSelfAndClass

: R|java/lang/Object| { +public final class ClassWithTypePRefSelfAndClass

|> : R|java/lang/Object| { } diff --git a/compiler/testData/loadJava/compiledJava/MethodTypePOneUpperBound.fir.txt b/compiler/testData/loadJava/compiledJava/MethodTypePOneUpperBound.fir.txt index db67f4bb303..39d258dbf41 100644 --- a/compiler/testData/loadJava/compiledJava/MethodTypePOneUpperBound.fir.txt +++ b/compiler/testData/loadJava/compiledJava/MethodTypePOneUpperBound.fir.txt @@ -1,4 +1,4 @@ public open class MethodTypePOneUpperBound : R|java/lang/Object| { - public open operator fun bar(): R|kotlin/Unit| + public open operator fun bar(): R|kotlin/Unit| } diff --git a/compiler/testData/loadJava/compiledJava/MethodTypePTwoUpperBounds.fir.txt b/compiler/testData/loadJava/compiledJava/MethodTypePTwoUpperBounds.fir.txt index c3493a910ce..fde40d2f8af 100644 --- a/compiler/testData/loadJava/compiledJava/MethodTypePTwoUpperBounds.fir.txt +++ b/compiler/testData/loadJava/compiledJava/MethodTypePTwoUpperBounds.fir.txt @@ -1,4 +1,4 @@ public open class MethodTypePTwoUpperBounds : R|java/lang/Object| { - public open operator fun foo(): R|kotlin/Unit| + public open operator fun foo(): R|kotlin/Unit| } diff --git a/compiler/testData/loadJava/compiledJava/MethodWithTypeP.fir.txt b/compiler/testData/loadJava/compiledJava/MethodWithTypeP.fir.txt index 667a6d440d0..9b2da20e095 100644 --- a/compiler/testData/loadJava/compiledJava/MethodWithTypeP.fir.txt +++ b/compiler/testData/loadJava/compiledJava/MethodWithTypeP.fir.txt @@ -1,4 +1,4 @@ public final class MethodWithTypeP : R|java/lang/Object| { - public final operator fun f(): R|kotlin/Unit| + public final operator fun

f(): R|kotlin/Unit| } diff --git a/compiler/testData/loadJava/compiledJava/MethodWithTypePP.fir.txt b/compiler/testData/loadJava/compiledJava/MethodWithTypePP.fir.txt index b03c621124e..213a125b8dc 100644 --- a/compiler/testData/loadJava/compiledJava/MethodWithTypePP.fir.txt +++ b/compiler/testData/loadJava/compiledJava/MethodWithTypePP.fir.txt @@ -1,4 +1,4 @@ public final class MethodWithTypePP : R|java/lang/Object| { - public final operator fun f(): R|kotlin/Unit| + public final operator fun f(): R|kotlin/Unit| } diff --git a/compiler/testData/loadJava/compiledJava/MethodWithTypePRefClassP.fir.txt b/compiler/testData/loadJava/compiledJava/MethodWithTypePRefClassP.fir.txt index e07006abeb4..a57651ef662 100644 --- a/compiler/testData/loadJava/compiledJava/MethodWithTypePRefClassP.fir.txt +++ b/compiler/testData/loadJava/compiledJava/MethodWithTypePRefClassP.fir.txt @@ -1,4 +1,4 @@ public open class MethodWithTypePRefClassP

: R|java/lang/Object| { - public final operator fun f(): R|kotlin/Unit| + public final operator fun f(): R|kotlin/Unit| } diff --git a/compiler/testData/loadJava/compiledJava/MethosWithPRefTP.fir.txt b/compiler/testData/loadJava/compiledJava/MethosWithPRefTP.fir.txt index eb03083182d..dff7ff10626 100644 --- a/compiler/testData/loadJava/compiledJava/MethosWithPRefTP.fir.txt +++ b/compiler/testData/loadJava/compiledJava/MethosWithPRefTP.fir.txt @@ -1,4 +1,4 @@ public final class MethosWithPRefTP : R|java/lang/Object| { - public final operator fun f(p: R|ft|!): R|kotlin/Unit| + public final operator fun

f(p: R|ft|!): R|kotlin/Unit| } diff --git a/compiler/testData/loadJava/compiledJava/RawUpperBound.fir.txt b/compiler/testData/loadJava/compiledJava/RawUpperBound.fir.txt index c778c6be5d6..a334596576a 100644 --- a/compiler/testData/loadJava/compiledJava/RawUpperBound.fir.txt +++ b/compiler/testData/loadJava/compiledJava/RawUpperBound.fir.txt @@ -1,2 +1,2 @@ -public abstract interface RawUpperBound : R|java/lang/Object| { +public abstract interface RawUpperBound|> : R|java/lang/Object| { } diff --git a/compiler/testData/loadJava/compiledJava/RecursiveRawUpperBound.fir.txt b/compiler/testData/loadJava/compiledJava/RecursiveRawUpperBound.fir.txt index 8afcb41fe3d..0b9cf69db72 100644 --- a/compiler/testData/loadJava/compiledJava/RecursiveRawUpperBound.fir.txt +++ b/compiler/testData/loadJava/compiledJava/RecursiveRawUpperBound.fir.txt @@ -1,2 +1,2 @@ -public abstract interface RecursiveRawUpperBound : R|java/lang/Object| { +public abstract interface RecursiveRawUpperBound|> : R|java/lang/Object| { } diff --git a/compiler/testData/loadJava/compiledJava/RecursiveWildcardUpperBound.fir.txt b/compiler/testData/loadJava/compiledJava/RecursiveWildcardUpperBound.fir.txt index ffda7a00d0d..6194b16dda8 100644 --- a/compiler/testData/loadJava/compiledJava/RecursiveWildcardUpperBound.fir.txt +++ b/compiler/testData/loadJava/compiledJava/RecursiveWildcardUpperBound.fir.txt @@ -1,2 +1,2 @@ -public abstract interface RecursiveWildcardUpperBound : R|java/lang/Object| { +public abstract interface RecursiveWildcardUpperBound|> : R|java/lang/Object| { } diff --git a/compiler/testData/loadJava/compiledJava/constructor/ConstructorGenericDeep.fir.txt b/compiler/testData/loadJava/compiledJava/constructor/ConstructorGenericDeep.fir.txt index 0741cf529e6..ea593adf21d 100644 --- a/compiler/testData/loadJava/compiledJava/constructor/ConstructorGenericDeep.fir.txt +++ b/compiler/testData/loadJava/compiledJava/constructor/ConstructorGenericDeep.fir.txt @@ -1,4 +1,4 @@ public open class ConstructorGenericDeep : R|java/lang/Object| { - public constructor(cl: R|ft>, java/lang/Class>?>|!): R|test/ConstructorGenericDeep| + public constructor

(cl: R|ft>, java/lang/Class>?>|!): R|test/ConstructorGenericDeep| } diff --git a/compiler/testData/loadJava/compiledJava/constructor/ConstructorGenericSimple.fir.txt b/compiler/testData/loadJava/compiledJava/constructor/ConstructorGenericSimple.fir.txt index 663cfdb6f06..6df2397340e 100644 --- a/compiler/testData/loadJava/compiledJava/constructor/ConstructorGenericSimple.fir.txt +++ b/compiler/testData/loadJava/compiledJava/constructor/ConstructorGenericSimple.fir.txt @@ -1,4 +1,4 @@ public open class ConstructorGenericSimple : R|java/lang/Object| { - public constructor(p: R|ft|!): R|test/ConstructorGenericSimple| + public constructor

(p: R|ft|!): R|test/ConstructorGenericSimple| } diff --git a/compiler/testData/loadJava/compiledJava/constructor/ConstructorGenericUpperBound.fir.txt b/compiler/testData/loadJava/compiledJava/constructor/ConstructorGenericUpperBound.fir.txt index 8279d55d6ee..66ef61fca46 100644 --- a/compiler/testData/loadJava/compiledJava/constructor/ConstructorGenericUpperBound.fir.txt +++ b/compiler/testData/loadJava/compiledJava/constructor/ConstructorGenericUpperBound.fir.txt @@ -1,4 +1,4 @@ public open class ConstructorGenericUpperBound : R|java/lang/Object| { - public constructor(p: R|ft|!): R|test/ConstructorGenericUpperBound| + public constructor

(p: R|ft|!): R|test/ConstructorGenericUpperBound| } diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/AllBoundsInWhen.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/AllBoundsInWhen.fir.txt index 18ac18b4f86..40b0f68444d 100644 --- a/compiler/testData/loadJava/compiledJava/kotlinSignature/AllBoundsInWhen.fir.txt +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/AllBoundsInWhen.fir.txt @@ -1,4 +1,4 @@ public open class AllBoundsInWhen : R|java/lang/Object| { - public open operator fun foo(): R|kotlin/Unit| + public open operator fun foo(): R|kotlin/Unit| } diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/ConstructorWithNewTypeParams.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/ConstructorWithNewTypeParams.fir.txt index 17996df11bb..40de11e3be7 100644 --- a/compiler/testData/loadJava/compiledJava/kotlinSignature/ConstructorWithNewTypeParams.fir.txt +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/ConstructorWithNewTypeParams.fir.txt @@ -1,4 +1,4 @@ public open class ConstructorWithNewTypeParams : R|java/lang/Object| { - public constructor(first: R|ft|!): R|test/ConstructorWithNewTypeParams| + public constructor(first: R|ft|!): R|test/ConstructorWithNewTypeParams| } diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/ConstructorWithParentTypeParams.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/ConstructorWithParentTypeParams.fir.txt index 936efdba8ff..933b4cd915d 100644 --- a/compiler/testData/loadJava/compiledJava/kotlinSignature/ConstructorWithParentTypeParams.fir.txt +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/ConstructorWithParentTypeParams.fir.txt @@ -1,4 +1,4 @@ public open class ConstructorWithParentTypeParams : R|java/lang/Object| { - public constructor(first: R|ft|!): R|test/ConstructorWithParentTypeParams| + public constructor(first: R|ft|!): R|test/ConstructorWithParentTypeParams| } diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/MethodWithMappedClasses.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/MethodWithMappedClasses.fir.txt index 29c33ee9d4a..1299871a77b 100644 --- a/compiler/testData/loadJava/compiledJava/kotlinSignature/MethodWithMappedClasses.fir.txt +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/MethodWithMappedClasses.fir.txt @@ -1,6 +1,6 @@ public open class MethodWithMappedClasses : R|java/lang/Object| { - public open operator fun copy(dest: R|ft, kotlin/collections/List?>|!, src: R|ft>, kotlin/collections/List>?>|!): R|kotlin/Unit| + public open operator fun copy(dest: R|ft, kotlin/collections/List?>|!, src: R|ft>, kotlin/collections/List>?>|!): R|kotlin/Unit| - public open operator fun copyMap(dest: R|ft, in T>, kotlin/collections/Map, in T>?>|!, src: R|ft, ft>, kotlin/collections/Map, ft>?>|!): R|kotlin/Unit| + public open operator fun copyMap(dest: R|ft, in T>, kotlin/collections/Map, in T>?>|!, src: R|ft, ft>, kotlin/collections/Map, ft>?>|!): R|kotlin/Unit| } diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/MethodWithTypeParameters.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/MethodWithTypeParameters.fir.txt index 2f908fd04cc..bd9dc50439e 100644 --- a/compiler/testData/loadJava/compiledJava/kotlinSignature/MethodWithTypeParameters.fir.txt +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/MethodWithTypeParameters.fir.txt @@ -1,4 +1,4 @@ public open class MethodWithTypeParameters : R|java/lang/Object| { - public open operator fun foo(a: R|ft|!, b: R|ft, kotlin/collections/List?>|!, list: R|ft, kotlin/collections/List?>|!): R|kotlin/Unit| + public open operator fun |> foo(a: R|ft|!, b: R|ft, kotlin/collections/List?>|!, list: R|ft, kotlin/collections/List?>|!): R|kotlin/Unit| } diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/error/WrongTypeParameterBoundStructure1.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/error/WrongTypeParameterBoundStructure1.fir.txt index 933ed5e3d56..9716754d605 100644 --- a/compiler/testData/loadJava/compiledJava/kotlinSignature/error/WrongTypeParameterBoundStructure1.fir.txt +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/error/WrongTypeParameterBoundStructure1.fir.txt @@ -1,4 +1,4 @@ public open class WrongTypeParameterBoundStructure1 : R|java/lang/Object| { - public open operator fun foo(a: R|ft|!, b: R|ft, kotlin/collections/List?>|!): R|kotlin/Unit| + public open operator fun |> foo(a: R|ft|!, b: R|ft, kotlin/collections/List?>|!): R|kotlin/Unit| } diff --git a/compiler/testData/loadJava/compiledJava/library/Max.fir.txt b/compiler/testData/loadJava/compiledJava/library/Max.fir.txt index 2387d915c3c..bd36d5831ec 100644 --- a/compiler/testData/loadJava/compiledJava/library/Max.fir.txt +++ b/compiler/testData/loadJava/compiledJava/library/Max.fir.txt @@ -1,4 +1,4 @@ public open class Max : R|java/lang/Object| { - public open operator fun max(coll: R|ft, kotlin/collections/Collection?>|!): R|ft|! + public open operator fun |> max(coll: R|ft, kotlin/collections/Collection?>|!): R|ft|! } diff --git a/compiler/testData/loadJava/compiledJava/mutability/LoadIterableWithNullability.fir.txt b/compiler/testData/loadJava/compiledJava/mutability/LoadIterableWithNullability.fir.txt index 7c50b599441..8c9da847053 100644 --- a/compiler/testData/loadJava/compiledJava/mutability/LoadIterableWithNullability.fir.txt +++ b/compiler/testData/loadJava/compiledJava/mutability/LoadIterableWithNullability.fir.txt @@ -1,10 +1,10 @@ public abstract interface LoadIterableWithNullability : R|java/lang/Object| { - @R|org/jetbrains/annotations/NotNull|() @R|kotlin/annotations/jvm/Mutable|() public abstract operator fun getIterable(): R|ft>, kotlin/collections/MutableIterable>>| + @R|org/jetbrains/annotations/NotNull|() @R|kotlin/annotations/jvm/Mutable|() public abstract operator fun getIterable(): R|kotlin/collections/MutableIterable>| - public abstract operator fun setIterable(@R|kotlin/annotations/jvm/Mutable|() @R|org/jetbrains/annotations/NotNull|() Iterable: R|ft>, kotlin/collections/MutableIterable>>|): R|kotlin/Unit| + public abstract operator fun setIterable(@R|kotlin/annotations/jvm/Mutable|() @R|org/jetbrains/annotations/NotNull|() Iterable: R|kotlin/collections/MutableIterable>|): R|kotlin/Unit| - @R|org/jetbrains/annotations/NotNull|() @R|kotlin/annotations/jvm/ReadOnly|() public abstract operator fun getReadOnlyIterable(): R|ft>, kotlin/collections/Iterable>>| + @R|org/jetbrains/annotations/NotNull|() @R|kotlin/annotations/jvm/ReadOnly|() public abstract operator fun getReadOnlyIterable(): R|kotlin/collections/Iterable>| - public abstract operator fun setReadOnlyIterable(@R|kotlin/annotations/jvm/ReadOnly|() @R|org/jetbrains/annotations/NotNull|() Iterable: R|ft>, kotlin/collections/Iterable>>|): R|kotlin/Unit| + public abstract operator fun setReadOnlyIterable(@R|kotlin/annotations/jvm/ReadOnly|() @R|org/jetbrains/annotations/NotNull|() Iterable: R|kotlin/collections/Iterable>|): R|kotlin/Unit| } diff --git a/compiler/testData/loadJava/compiledJava/sam/GenericInterfaceParameterWithSelfBound.fir.txt b/compiler/testData/loadJava/compiledJava/sam/GenericInterfaceParameterWithSelfBound.fir.txt index 1783977f3f4..af21113fc4c 100644 --- a/compiler/testData/loadJava/compiledJava/sam/GenericInterfaceParameterWithSelfBound.fir.txt +++ b/compiler/testData/loadJava/compiledJava/sam/GenericInterfaceParameterWithSelfBound.fir.txt @@ -1,4 +1,4 @@ -public abstract interface GenericInterfaceParameterWithSelfBound : R|java/lang/Object| { +public abstract interface GenericInterfaceParameterWithSelfBound|> : R|java/lang/Object| { public abstract operator fun method(t: R|ft|!): R|ft|! } diff --git a/compiler/testData/loadJava/compiledJava/sam/GenericInterfaceParametersWithBounds.fir.txt b/compiler/testData/loadJava/compiledJava/sam/GenericInterfaceParametersWithBounds.fir.txt index be504e44519..dbdedd38984 100644 --- a/compiler/testData/loadJava/compiledJava/sam/GenericInterfaceParametersWithBounds.fir.txt +++ b/compiler/testData/loadJava/compiledJava/sam/GenericInterfaceParametersWithBounds.fir.txt @@ -1,4 +1,4 @@ -public abstract interface GenericInterfaceParametersWithBounds : R|java/lang/Object| { +public abstract interface GenericInterfaceParametersWithBounds|, R|java/lang/Cloneable|, B : R|java/util/List|> : R|java/lang/Object| { public abstract operator fun method(a: R|kotlin/Array>|, b: R|ft|!): R|kotlin/Unit| } diff --git a/compiler/testData/loadJava/compiledJava/sam/GenericMethodParameters.fir.txt b/compiler/testData/loadJava/compiledJava/sam/GenericMethodParameters.fir.txt index 0e6a640c569..d39cd2966a7 100644 --- a/compiler/testData/loadJava/compiledJava/sam/GenericMethodParameters.fir.txt +++ b/compiler/testData/loadJava/compiledJava/sam/GenericMethodParameters.fir.txt @@ -1,4 +1,4 @@ public abstract interface GenericMethodParameters : R|java/lang/Object| { - public abstract operator fun method(a: R|kotlin/Array>|, b: R|ft|!): R|kotlin/Unit| + public abstract operator fun |> method(a: R|kotlin/Array>|, b: R|ft|!): R|kotlin/Unit| } diff --git a/compiler/testData/loadJava/compiledJava/sam/adapters/TypeParameterOfMethod.fir.txt b/compiler/testData/loadJava/compiledJava/sam/adapters/TypeParameterOfMethod.fir.txt index aec8ef078bc..6974895fefe 100644 --- a/compiler/testData/loadJava/compiledJava/sam/adapters/TypeParameterOfMethod.fir.txt +++ b/compiler/testData/loadJava/compiledJava/sam/adapters/TypeParameterOfMethod.fir.txt @@ -1,8 +1,8 @@ public open class TypeParameterOfMethod : R|java/lang/Object| { - public open static operator fun max(comparator: R|ft>, java/util/Comparator>?>|!, value1: R|ft|!, value2: R|ft|!): R|ft|! + public open static operator fun max(comparator: R|ft>, java/util/Comparator>?>|!, value1: R|ft|!, value2: R|ft|!): R|ft|! - public open static operator fun max2(comparator: R|ft>, java/util/Comparator>?>|!, value1: R|ft|!, value2: R|ft|!): R|ft|! + public open static operator fun max2(comparator: R|ft>, java/util/Comparator>?>|!, value1: R|ft|!, value2: R|ft|!): R|ft|! - public open static operator fun method(a: R|ft>, java/util/Comparator>?>|!, b: R|ft|!): R|kotlin/Unit| + public open static operator fun |> method(a: R|ft>, java/util/Comparator>?>|!, b: R|ft|!): R|kotlin/Unit| } diff --git a/compiler/testData/loadJava/compiledJava/static/StaticMembersInEnum.fir.txt b/compiler/testData/loadJava/compiledJava/static/StaticMembersInEnum.fir.txt index af7d2f8c1a4..2f510f908a6 100644 --- a/compiler/testData/loadJava/compiledJava/static/StaticMembersInEnum.fir.txt +++ b/compiler/testData/loadJava/compiledJava/static/StaticMembersInEnum.fir.txt @@ -15,6 +15,6 @@ public final enum class StaticMembersInEnum : R|java/lang/Enum: R|ft>, java/lang/Class>?>|!, : R|ft|!): R|ft|! + public open static operator fun |> valueOf(: R|ft>, java/lang/Class>?>|!, : R|ft|!): R|ft|! }