azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Introduce TypeParameterUpperBoundEraser to memorize results of type parameters erasion computation

Browse Source 
^KT-47785 Fixed
This commit is contained in:
Victor Petukhov
2021-07-21 13:29:44 +03:00
committed by teamcityserver
parent f9cb0d61a8
commit 6706ee87ad
13 changed files with 309 additions and 74 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirBlackBoxCodegenTestGenerated.java
Generated
+6
View File
@@ -28078,6 +28078,12 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT
runTest("compiler/testData/codegen/box/platformTypes/kt14989.kt");
}
@Test
@TestMetadata("kt47785.kt")
public void testKt47785() throws Exception {
runTest("compiler/testData/codegen/box/platformTypes/kt47785.kt");
}
@Test
@TestMetadata("rawTypeWithNestedClass.kt")
public void testRawTypeWithNestedClass() throws Exception {
compiler/testData/codegen/box/platformTypes/kt47785.kt
Vendored
+127
View File
@@ -0,0 +1,127 @@
// DONT_TARGET_EXACT_BACKEND: WASM
// FULL_JDK
// FILE: AbstractAssert.java
public abstract class AbstractAssert<E extends AbstractAssert<E>> { }
// FILE: AbstractAssertWithOriginWithColumnsAndRows.java
public abstract class AbstractAssertWithOriginWithColumnsAndRows<E extends AbstractAssertWithOriginWithColumnsAndRows<E, O, D, A, C, CV, R, RV>, O extends OriginWithColumnsAndRows<C, R>, D extends AbstractDbData<D>, A extends AbstractDbAssert<D, A, C, CV, R, RV>, C extends AbstractColumnAssert<D, A, C, CV, R, RV>, CV extends AbstractColumnValueAssert<D, A, C, CV, R, RV>, R extends AbstractRowAssert<D, A, C, CV, R, RV>, RV extends AbstractRowValueAssert<D, A, C, CV, R, RV>> {}
// FILE: AbstractColumnAssert.java
public abstract class AbstractColumnAssert<D extends AbstractDbData<D>, A extends AbstractDbAssert<D, A, C, CV, R, RV>, C extends AbstractColumnAssert<D, A, C, CV, R, RV>, CV extends AbstractColumnValueAssert<D, A, C, CV, R, RV>, R extends AbstractRowAssert<D, A, C, CV, R, RV>, RV extends AbstractRowValueAssert<D, A, C, CV, R, RV>>
extends AbstractSubAssert<D, A, C, CV, C, CV, R, RV> implements ColumnElement {
}
// FILE: AbstractColumnValueAssert.java
public abstract class AbstractColumnValueAssert<D extends AbstractDbData<D>, A extends AbstractDbAssert<D, A, C, CV, R, RV>, C extends AbstractColumnAssert<D, A, C, CV, R, RV>, CV extends AbstractColumnValueAssert<D, A, C, CV, R, RV>, R extends AbstractRowAssert<D, A, C, CV, R, RV>, RV extends AbstractRowValueAssert<D, A, C, CV, R, RV>>
extends AbstractValueAssert<D, A, C, CV, C, CV, R, RV> {
}
// FILE: AbstractDbAssert.java
public abstract class AbstractDbAssert<D extends AbstractDbData<D>, A extends AbstractDbAssert<D, A, C, CV, R, RV>, C extends AbstractColumnAssert<D, A, C, CV, R, RV>, CV extends AbstractColumnValueAssert<D, A, C, CV, R, RV>, R extends AbstractRowAssert<D, A, C, CV, R, RV>, RV extends AbstractRowValueAssert<D, A, C, CV, R, RV>>
extends AbstractAssert<A> implements OriginWithColumnsAndRows<C, R> {
public A hasNumberOfRows(int expected) {
return (A) new RequestAssert();
}
public R row() {
return (R) new RequestRowAssert();
}
}
// FILE: AbstractDbData.java
public abstract class AbstractDbData<D extends AbstractDbData<D>> extends AbstractDbElement<D> {
}
// FILE: AbstractDbElement.java
public abstract class AbstractDbElement<D extends AbstractDbElement<D>> {
}
// FILE: AbstractRowAssert.java
public abstract class AbstractRowAssert<D extends AbstractDbData<D>, A extends AbstractDbAssert<D, A, C, CV, R, RV>, C extends AbstractColumnAssert<D, A, C, CV, R, RV>, CV extends AbstractColumnValueAssert<D, A, C, CV, R, RV>, R extends AbstractRowAssert<D, A, C, CV, R, RV>, RV extends AbstractRowValueAssert<D, A, C, CV, R, RV>>
extends AbstractSubAssert<D, A, R, RV, C, CV, R, RV> implements RowElement {
public RV value(String columnName) {
return (RV) new RequestRowValueAssert();
}
}
// FILE: AbstractRowValueAssert.java
public abstract class AbstractRowValueAssert<D extends AbstractDbData<D>, A extends AbstractDbAssert<D, A, C, CV, R, RV>, C extends AbstractColumnAssert<D, A, C, CV, R, RV>, CV extends AbstractColumnValueAssert<D, A, C, CV, R, RV>, R extends AbstractRowAssert<D, A, C, CV, R, RV>, RV extends AbstractRowValueAssert<D, A, C, CV, R, RV>>
extends AbstractValueAssert<D, A, R, RV, C, CV, R, RV> {
}
// FILE: AbstractSubAssert.java
public abstract class AbstractSubAssert<D extends AbstractDbData<D>, A extends AbstractDbAssert<D, A, C, CV, R, RV>, S extends AbstractSubAssert<D, A, S, V, C, CV, R, RV>, V extends AbstractValueAssert<D, A, S, V, C, CV, R, RV>, C extends AbstractColumnAssert<D, A, C, CV, R, RV>, CV extends AbstractColumnValueAssert<D, A, C, CV, R, RV>, R extends AbstractRowAssert<D, A, C, CV, R, RV>, RV extends AbstractRowValueAssert<D, A, C, CV, R, RV>>
extends AbstractAssertWithOriginWithColumnsAndRows<S, A, D, A, C, CV, R, RV> implements OriginWithColumnsAndRows<C, R> {
}
// FILE: AbstractValueAssert.java
import java.time.LocalDateTime;
public abstract class AbstractValueAssert<D extends AbstractDbData<D>, A extends AbstractDbAssert<D, A, C, CV, R, RV>, S extends AbstractSubAssert<D, A, S, V, C, CV, R, RV>, V extends AbstractValueAssert<D, A, S, V, C, CV, R, RV>, C extends AbstractColumnAssert<D, A, C, CV, R, RV>, CV extends AbstractColumnValueAssert<D, A, C, CV, R, RV>, R extends AbstractRowAssert<D, A, C, CV, R, RV>, RV extends AbstractRowValueAssert<D, A, C, CV, R, RV>>
extends AbstractAssertWithOriginWithColumnsAndRows<V, S, D, A, C, CV, R, RV> {
public V isEqualTo(LocalDateTime expected) {
return (V) new RequestRowValueAssert();
}
}
// FILE: ColumnElement.java
public interface ColumnElement { }
// FILE: OriginWithColumnsAndRows.java
public interface OriginWithColumnsAndRows<C extends ColumnElement, R extends RowElement> {}
// FILE: Request.java
public class Request extends AbstractDbData<Request> {}
// FILE: RequestAssert.java
public class RequestAssert
extends AbstractDbAssert<Request, RequestAssert, RequestColumnAssert, RequestColumnValueAssert, RequestRowAssert, RequestRowValueAssert> {
}
// FILE: RequestColumnAssert.java
public class RequestColumnAssert
extends AbstractColumnAssert<Request, RequestAssert, RequestColumnAssert, RequestColumnValueAssert, RequestRowAssert, RequestRowValueAssert> {
}
// FILE: RequestColumnValueAssert.java
public class RequestColumnValueAssert
extends AbstractColumnValueAssert<Request, RequestAssert, RequestColumnAssert, RequestColumnValueAssert, RequestRowAssert, RequestRowValueAssert> {
}
// FILE: RequestRowAssert.java
public class RequestRowAssert
extends AbstractRowAssert<Request, RequestAssert, RequestColumnAssert, RequestColumnValueAssert, RequestRowAssert, RequestRowValueAssert> {
}
// FILE: RequestRowValueAssert.java
public class RequestRowValueAssert
extends AbstractRowValueAssert<Request, RequestAssert, RequestColumnAssert, RequestColumnValueAssert, RequestRowAssert, RequestRowValueAssert> {
}
// FILE: RowElement.java
public interface RowElement {}
// FILE: main.kt
import java.time.LocalDateTime
fun test(x: RequestAssert) {
val timestamp = LocalDateTime.now()
x.hasNumberOfRows(1)
.row()
.value("message_time").isEqualTo(timestamp)
}
fun box(): String {
test(RequestAssert())
return "OK"
}
compiler/testData/diagnostics/tests/platformTypes/rawTypes/intermediateRecursion.txt
Vendored
+1 -1
View File
@@ -17,5 +17,5 @@ public open class Foo</*0*/ T : Boo<K!>!, /*1*/ K : Boo<X!>!, /*2*/ X : Boo<K!>!
public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
// Static members
public/*package*/ open fun test1(): (Foo<(raw) Boo<Boo<Boo<*>!>!>!, (raw) Boo<Boo<*>!>!, (raw) Boo<Boo<*>!>!>..Foo<out Boo<out Boo<out Boo<*>!>!>!, out Boo<out Boo<*>!>!, out Boo<out Boo<*>!>!>?)
public/*package*/ open fun test1(): (Foo<(raw) Boo<Boo<Boo<*>!>!>!, (raw) Boo<Boo<*>!>!, (raw) Boo<*>!>..Foo<out Boo<out Boo<out Boo<*>!>!>!, out Boo<out Boo<*>!>!, out Boo<*>!>?)
}
compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/BlackBoxCodegenTestGenerated.java
Generated
+6
View File
@@ -27976,6 +27976,12 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest {
runTest("compiler/testData/codegen/box/platformTypes/kt14989.kt");
}
@Test
@TestMetadata("kt47785.kt")
public void testKt47785() throws Exception {
runTest("compiler/testData/codegen/box/platformTypes/kt47785.kt");
}
@Test
@TestMetadata("rawTypeWithNestedClass.kt")
public void testRawTypeWithNestedClass() throws Exception {
compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBlackBoxCodegenTestGenerated.java
Generated
+6
View File
@@ -28078,6 +28078,12 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes
runTest("compiler/testData/codegen/box/platformTypes/kt14989.kt");
}
@Test
@TestMetadata("kt47785.kt")
public void testKt47785() throws Exception {
runTest("compiler/testData/codegen/box/platformTypes/kt47785.kt");
}
@Test
@TestMetadata("rawTypeWithNestedClass.kt")
public void testRawTypeWithNestedClass() throws Exception {
compiler/tests-gen/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java
Generated
+5
View File
@@ -23755,6 +23755,11 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes
runTest("compiler/testData/codegen/box/platformTypes/kt14989.kt");
}
@TestMetadata("kt47785.kt")
public void testKt47785() throws Exception {
runTest("compiler/testData/codegen/box/platformTypes/kt47785.kt");
}
@TestMetadata("rawTypeWithNestedClass.kt")
public void testRawTypeWithNestedClass() throws Exception {
runTest("compiler/testData/codegen/box/platformTypes/rawTypeWithNestedClass.kt");
core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/context.kt
+1
View File
@@ -29,6 +29,7 @@ import org.jetbrains.kotlin.load.java.components.JavaPropertyInitializerEvaluato
import org.jetbrains.kotlin.load.java.components.JavaResolverCache
import org.jetbrains.kotlin.load.java.components.SignaturePropagator
import org.jetbrains.kotlin.load.java.lazy.types.JavaTypeResolver
import org.jetbrains.kotlin.load.java.lazy.types.TypeParameterUpperBoundEraser
import org.jetbrains.kotlin.load.java.sources.JavaSourceElementFactory
import org.jetbrains.kotlin.load.java.structure.JavaTypeParameterListOwner
import org.jetbrains.kotlin.load.java.typeEnhancement.SignatureEnhancement
core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/types/JavaTypeResolver.kt
+9 -71
View File
@@ -41,6 +41,7 @@ class JavaTypeResolver(
private val c: LazyJavaResolverContext,
private val typeParameterResolver: TypeParameterResolver
) {
val typeParameterUpperBoundEraser = TypeParameterUpperBoundEraser()
fun transformJavaType(javaType: JavaType?, attr: JavaTypeAttributes): KotlinType {
return when (javaType) {
@@ -229,9 +230,11 @@ class JavaTypeResolver(
// so we get A<*, *>.
// Summary result for upper bound of T is `A<A<*, *>, A<*, *>>..A<out A<*, *>, out A<*, *>>`
val erasedUpperBound = LazyWrappedType(c.storageManager) {
parameter.getErasedUpperBound(isRaw, attr) {
constructor.declarationDescriptor!!.defaultType.replaceArgumentsWithStarProjections()
}
typeParameterUpperBoundEraser.getErasedUpperBound(
parameter,
isRaw,
attr.withDefaultType(constructor.declarationDescriptor?.defaultType)
)
}
RawSubstitution.computeProjection(
@@ -310,9 +313,11 @@ data class JavaTypeAttributes(
val flexibility: JavaTypeFlexibility = INFLEXIBLE,
val isForAnnotationParameter: Boolean = false,
// we use it to prevent happening a recursion while compute type parameter's upper bounds
val visitedTypeParameters: Set<TypeParameterDescriptor>? = null
val visitedTypeParameters: Set<TypeParameterDescriptor>? = null,
val defaultType: SimpleType? = null
) {
fun withFlexibility(flexibility: JavaTypeFlexibility) = copy(flexibility = flexibility)
fun withDefaultType(type: SimpleType?) = copy(defaultType = type)
fun withNewVisitedTypeParameter(typeParameter: TypeParameterDescriptor) =
copy(visitedTypeParameters = if (visitedTypeParameters != null) visitedTypeParameters + typeParameter else setOf(typeParameter))
}
@@ -331,70 +336,3 @@ fun TypeUsage.toAttributes(
isForAnnotationParameter = isForAnnotationParameter,
visitedTypeParameters = upperBoundForTypeParameter?.let(::setOf)
)
// Definition:
// ErasedUpperBound(T : G<t>) = G<*> // UpperBound(T) is a type G<t> with arguments
// ErasedUpperBound(T : A) = A // UpperBound(T) is a type A without arguments
// ErasedUpperBound(T : F) = UpperBound(F) // UB(T) is another type parameter F
internal fun TypeParameterDescriptor.getErasedUpperBound(
// Calculation of `potentiallyRecursiveTypeParameter.upperBounds` may recursively depend on `this.getErasedUpperBound`
// E.g. `class A<T extends A, F extends A>`
// To prevent recursive calls return defaultValue() instead
isRaw: Boolean,
typeAttr: JavaTypeAttributes,
defaultValue: (() -> KotlinType) = { ErrorUtils.createErrorType("Can't compute erased upper bound of type parameter `$this`") }
): KotlinType {
val visitedTypeParameters = typeAttr.visitedTypeParameters
if (visitedTypeParameters != null && original in visitedTypeParameters) return defaultValue()
/*
* We should do erasure of containing type parameters with their erasure to avoid creating inconsistent types.
* E.g. for `class Foo<T: Foo<B>, B>`, we'd have erasure for lower bound: Foo<Foo<*>, Any>,
* but it's wrong type: projection(*) != projection(Any).
* So we should substitute erasure of the corresponding type parameter: `Foo<Foo<Any>, Any>` or `Foo<Foo<*>, *>`.
*/
val erasedUpperBounds = defaultType.extractTypeParametersFromUpperBounds(visitedTypeParameters).associate {
val boundProjection = if (visitedTypeParameters == null || it !in visitedTypeParameters) {
RawSubstitution.computeProjection(
it,
// if erasure happens due to invalid arguments number, use star projections instead
if (isRaw) typeAttr else typeAttr.withFlexibility(INFLEXIBLE),
it.getErasedUpperBound(isRaw, typeAttr.withNewVisitedTypeParameter(this))
)
} else makeStarProjection(it, typeAttr)
it.typeConstructor to boundProjection
}
val erasedUpperBoundsSubstitutor = TypeSubstitutor.create(TypeConstructorSubstitution.createByConstructorsMap(erasedUpperBounds))
val firstUpperBound = upperBounds.first()
if (firstUpperBound.constructor.declarationDescriptor is ClassDescriptor) {
return firstUpperBound.replaceArgumentsWithStarProjectionOrMapped(
erasedUpperBoundsSubstitutor,
erasedUpperBounds,
OUT_VARIANCE,
typeAttr.visitedTypeParameters
)
}
val stopAt = typeAttr.visitedTypeParameters ?: setOf(this)
var current = firstUpperBound.constructor.declarationDescriptor as TypeParameterDescriptor
while (current !in stopAt) {
val nextUpperBound = current.upperBounds.first()
if (nextUpperBound.constructor.declarationDescriptor is ClassDescriptor) {
return nextUpperBound.replaceArgumentsWithStarProjectionOrMapped(
erasedUpperBoundsSubstitutor,
erasedUpperBounds,
OUT_VARIANCE,
typeAttr.visitedTypeParameters
)
}
current = nextUpperBound.constructor.declarationDescriptor as TypeParameterDescriptor
}
return defaultValue()
}
core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/types/RawType.kt
+5 -2
View File
@@ -104,12 +104,15 @@ class RawTypeImpl private constructor(lowerBound: SimpleType, upperBound: Simple
internal object RawSubstitution : TypeSubstitution() {
override fun get(key: KotlinType) = TypeProjectionImpl(eraseType(key))
private val typeParameterUpperBoundEraser = TypeParameterUpperBoundEraser()
private val lowerTypeAttr = TypeUsage.COMMON.toAttributes().withFlexibility(JavaTypeFlexibility.FLEXIBLE_LOWER_BOUND)
private val upperTypeAttr = TypeUsage.COMMON.toAttributes().withFlexibility(JavaTypeFlexibility.FLEXIBLE_UPPER_BOUND)
private fun eraseType(type: KotlinType, attr: JavaTypeAttributes = JavaTypeAttributes(TypeUsage.COMMON)): KotlinType {
return when (val declaration = type.constructor.declarationDescriptor) {
is TypeParameterDescriptor -> eraseType(declaration.getErasedUpperBound(isRaw = true, attr), attr)
is TypeParameterDescriptor ->
eraseType(typeParameterUpperBoundEraser.getErasedUpperBound(declaration, isRaw = true, attr), attr)
is ClassDescriptor -> {
val declarationForUpper =
type.upperIfFlexible().constructor.declarationDescriptor
@@ -170,7 +173,7 @@ internal object RawSubstitution : TypeSubstitution() {
fun computeProjection(
parameter: TypeParameterDescriptor,
attr: JavaTypeAttributes,
erasedUpperBound: KotlinType = parameter.getErasedUpperBound(isRaw = true, attr)
erasedUpperBound: KotlinType = typeParameterUpperBoundEraser.getErasedUpperBound(parameter, isRaw = true, attr)
) = when (attr.flexibility) {
// Raw(List<T>) => (List<Any?>..List<*>)
// Raw(Enum<T>) => (Enum<Enum<*>>..Enum<out Enum<*>>)
core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/types/TypeParameterUpperBoundEraser.kt
+128
View File
@@ -0,0 +1,128 @@
/*
* Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
* 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.load.java.lazy.types
import org.jetbrains.kotlin.descriptors.ClassDescriptor
import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
import org.jetbrains.kotlin.storage.LockBasedStorageManager
import org.jetbrains.kotlin.types.*
import org.jetbrains.kotlin.types.typeUtil.extractTypeParametersFromUpperBounds
import org.jetbrains.kotlin.types.typeUtil.replaceArgumentsWithStarProjectionOrMapped
import org.jetbrains.kotlin.types.typeUtil.replaceArgumentsWithStarProjections
class TypeParameterUpperBoundEraser {
private val storage = LockBasedStorageManager("Type parameter upper bound erasion results")
private val erroneousErasedBound by lazy {
ErrorUtils.createErrorType("Can't compute erased upper bound of type parameter `$this`")
}
private data class DataToEraseUpperBound(
val typeParameter: TypeParameterDescriptor,
val isRaw: Boolean,
val typeAttr: JavaTypeAttributes
) {
override fun equals(other: Any?): Boolean {
if (other !is DataToEraseUpperBound) return false
return other.typeParameter == this.typeParameter
&& other.isRaw == this.isRaw
&& other.typeAttr.flexibility == this.typeAttr.flexibility
&& other.typeAttr.howThisTypeIsUsed == this.typeAttr.howThisTypeIsUsed
&& other.typeAttr.isForAnnotationParameter == this.typeAttr.isForAnnotationParameter
&& other.typeAttr.defaultType == this.typeAttr.defaultType
}
override fun hashCode(): Int {
var result = typeParameter.hashCode()
result += 31 * result + if (isRaw) 1 else 0
result += 31 * result + typeAttr.flexibility.hashCode()
result += 31 * result + typeAttr.howThisTypeIsUsed.hashCode()
result += 31 * result + if (typeAttr.isForAnnotationParameter) 1 else 0
result += 31 * result + typeAttr.defaultType.hashCode()
return result
}
}
private val getErasedUpperBound = storage.createMemoizedFunction<DataToEraseUpperBound, KotlinType> {
with(it) { getErasedUpperBoundInternal(typeParameter, isRaw, typeAttr) }
}
internal fun getErasedUpperBound(
typeParameter: TypeParameterDescriptor,
isRaw: Boolean,
typeAttr: JavaTypeAttributes
) = getErasedUpperBound(DataToEraseUpperBound(typeParameter, isRaw, typeAttr))
private fun getDefaultType(typeAttr: JavaTypeAttributes) =
typeAttr.defaultType?.replaceArgumentsWithStarProjections() ?: erroneousErasedBound
// Definition:
// ErasedUpperBound(T : G<t>) = G<*> // UpperBound(T) is a type G<t> with arguments
// ErasedUpperBound(T : A) = A // UpperBound(T) is a type A without arguments
// ErasedUpperBound(T : F) = UpperBound(F) // UB(T) is another type parameter F
private fun getErasedUpperBoundInternal(
// Calculation of `potentiallyRecursiveTypeParameter.upperBounds` may recursively depend on `this.getErasedUpperBound`
// E.g. `class A<T extends A, F extends A>`
// To prevent recursive calls return defaultValue() instead
typeParameter: TypeParameterDescriptor,
isRaw: Boolean,
typeAttr: JavaTypeAttributes
): KotlinType {
val visitedTypeParameters = typeAttr.visitedTypeParameters
if (visitedTypeParameters != null && typeParameter.original in visitedTypeParameters)
return getDefaultType(typeAttr)
/*
* We should do erasure of containing type parameters with their erasure to avoid creating inconsistent types.
* E.g. for `class Foo<T: Foo<B>, B>`, we'd have erasure for lower bound: Foo<Foo<*>, Any>,
* but it's wrong type: projection(*) != projection(Any).
* So we should substitute erasure of the corresponding type parameter: `Foo<Foo<Any>, Any>` or `Foo<Foo<*>, *>`.
*/
val erasedUpperBounds = typeParameter.defaultType.extractTypeParametersFromUpperBounds(visitedTypeParameters).associate {
val boundProjection = if (visitedTypeParameters == null || it !in visitedTypeParameters) {
RawSubstitution.computeProjection(
it,
// if erasure happens due to invalid arguments number, use star projections instead
if (isRaw) typeAttr else typeAttr.withFlexibility(JavaTypeFlexibility.INFLEXIBLE),
getErasedUpperBound(it, isRaw, typeAttr.withNewVisitedTypeParameter(typeParameter))
)
} else makeStarProjection(it, typeAttr)
it.typeConstructor to boundProjection
}
val erasedUpperBoundsSubstitutor = TypeSubstitutor.create(TypeConstructorSubstitution.createByConstructorsMap(erasedUpperBounds))
val firstUpperBound = typeParameter.upperBounds.first()
if (firstUpperBound.constructor.declarationDescriptor is ClassDescriptor) {
return firstUpperBound.replaceArgumentsWithStarProjectionOrMapped(
erasedUpperBoundsSubstitutor,
erasedUpperBounds,
Variance.OUT_VARIANCE,
typeAttr.visitedTypeParameters
)
}
val stopAt = typeAttr.visitedTypeParameters ?: setOf(this)
var current = firstUpperBound.constructor.declarationDescriptor as TypeParameterDescriptor
while (current !in stopAt) {
val nextUpperBound = current.upperBounds.first()
if (nextUpperBound.constructor.declarationDescriptor is ClassDescriptor) {
return nextUpperBound.replaceArgumentsWithStarProjectionOrMapped(
erasedUpperBoundsSubstitutor,
erasedUpperBounds,
Variance.OUT_VARIANCE,
typeAttr.visitedTypeParameters
)
}
current = nextUpperBound.constructor.declarationDescriptor as TypeParameterDescriptor
}
return getDefaultType(typeAttr)
}
}
js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/es6/semantics/IrJsCodegenBoxES6TestGenerated.java
Generated
+5
View File
@@ -18664,6 +18664,11 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes
runTest("compiler/testData/codegen/box/platformTypes/inferenceFlexibleTToNullable.kt");
}
@TestMetadata("kt47785.kt")
public void testKt47785() throws Exception {
runTest("compiler/testData/codegen/box/platformTypes/kt47785.kt");
}
@TestMetadata("compiler/testData/codegen/box/platformTypes/primitives")
@TestDataPath("$PROJECT_ROOT")
@RunWith(JUnit3RunnerWithInners.class)
js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/ir/semantics/IrJsCodegenBoxTestGenerated.java
Generated
+5
View File
@@ -18070,6 +18070,11 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest {
runTest("compiler/testData/codegen/box/platformTypes/inferenceFlexibleTToNullable.kt");
}
@TestMetadata("kt47785.kt")
public void testKt47785() throws Exception {
runTest("compiler/testData/codegen/box/platformTypes/kt47785.kt");
}
@TestMetadata("compiler/testData/codegen/box/platformTypes/primitives")
@TestDataPath("$PROJECT_ROOT")
@RunWith(JUnit3RunnerWithInners.class)
js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/semantics/JsCodegenBoxTestGenerated.java
Generated
+5
View File
@@ -18135,6 +18135,11 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest {
runTest("compiler/testData/codegen/box/platformTypes/inferenceFlexibleTToNullable.kt");
}
@TestMetadata("kt47785.kt")
public void testKt47785() throws Exception {
runTest("compiler/testData/codegen/box/platformTypes/kt47785.kt");
}
@TestMetadata("compiler/testData/codegen/box/platformTypes/primitives")
@TestDataPath("$PROJECT_ROOT")
@RunWith(JUnit3RunnerWithInners.class)