From 406e31f54a251fc26f0b267ad65bcdc05440c85e Mon Sep 17 00:00:00 2001 From: Denis Zharkov Date: Mon, 23 Nov 2015 19:45:48 +0300 Subject: [PATCH] Change default rules for declaration-site wildcards Mostly this commit is about skipping wildcards that are redundant in some sense. The motivation is that they looks `long` in Java code. There are basically two important parts: return types and value parameters. 1. For return types default behaviour is skipping all declaration-site wildcards. The intuition behind this rule is simple: return types are basically used in subtype position (as an argument for another call), and here everything works well in case of 'out'-variance. For example we have 'Out>>' as subtype both for 'Out>>' and 'Out>>', so values of such type is more flexible in contrast to `Out>>` that could be used only for the second case. But we have choosen to treat `in`-variance in a different way: argument itself should be rendered without wildcard while nested arguments are rendered by the rules described further (see second part). For example: 'In>' will have generic signature 'In>'. If we omit all wildcards here, then value of type 'In>' will be impossible to use as argument for function expecting 'In>' where Derived <: OpenClass (you can check it manually :]). And this exception should not be very inconvinient because in-variance is rather rare. 2. For value parameters we decided to skip wildcards if it doesn't make obtained signature weaker in a sense of set of acceptable arguments. More precisely: a. We write wildcard for 'Out' iff T ``can have subtypes ignoring nullability'' b. We write wildcard for 'In' iff T is not equal to it's class upper bound (ignoring nullability again) Definition of ``can have subtypes ignoring nullability'' is straightforward and you can see it in commit. #KT-9801 Fixed #KT-9890 Fixed --- .../kotlin/codegen/state/JetTypeMapper.java | 72 +++++++-------- .../kotlin/codegen/state/TypeMappingMode.kt | 57 ++++++++++-- .../kotlin/codegen/state/typeMappingUtil.kt | 69 +++++++++++++++ .../genericSignature/covariantOverride.kt | 16 ++++ .../ConstructorCollectionParameter.kt | 2 +- .../FunctionTwoTypeParameters.kt | 2 +- .../GenericOverrides.kt | 40 +++++++++ .../InOfOutInInPosition.kt | 2 +- .../InOfOutInOutPosition.kt | 2 +- .../OpenMembersReturnType.kt | 51 +++++++++++ .../OpenMembersValueParameter.kt | 58 +++++++++++++ .../OutInInPosition.kt | 2 +- .../OutOfInInOutPosition.kt | 2 +- .../OutOfOutInInPosition.kt | 2 +- .../OutOfOutInOutPosition.kt | 19 ++-- .../PropertySetterOut.kt | 2 +- .../argumentOverridability.kt | 25 ++++++ .../wildcardOptimization/arrays.kt | 23 +++++ .../complicatedInBounds.kt | 12 +++ .../wildcardOptimization/deepOut.kt | 12 +++ .../wildcardOptimization/finalReturnType.kt | 31 +++++++ .../wildcardOptimization/outIn.kt | 12 +++ .../wildcardOptimization/outInv.kt | 25 ++++++ .../wildcardOptimization/topLevelIn.kt | 15 ++++ .../wildcardOptimization/topLevelInv.kt | 24 +++++ .../wildcardOptimization/typeParameter.kt | 8 ++ ...lackBoxWithStdlibCodegenTestGenerated.java | 6 ++ .../compiler/WriteSignatureTestGenerated.java | 87 +++++++++++++++++++ .../mutableCollections/Overrides.java | 2 +- 29 files changed, 620 insertions(+), 60 deletions(-) create mode 100644 compiler/backend/src/org/jetbrains/kotlin/codegen/state/typeMappingUtil.kt create mode 100644 compiler/testData/codegen/boxWithStdlib/reflection/genericSignature/covariantOverride.kt create mode 100644 compiler/testData/writeSignature/declarationSiteVariance/GenericOverrides.kt create mode 100644 compiler/testData/writeSignature/declarationSiteVariance/OpenMembersReturnType.kt create mode 100644 compiler/testData/writeSignature/declarationSiteVariance/OpenMembersValueParameter.kt create mode 100644 compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization/argumentOverridability.kt create mode 100644 compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization/arrays.kt create mode 100644 compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization/complicatedInBounds.kt create mode 100644 compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization/deepOut.kt create mode 100644 compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization/finalReturnType.kt create mode 100644 compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization/outIn.kt create mode 100644 compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization/outInv.kt create mode 100644 compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization/topLevelIn.kt create mode 100644 compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization/topLevelInv.kt create mode 100644 compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization/typeParameter.kt diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/JetTypeMapper.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/JetTypeMapper.java index 3de8d55cc9a..2d4d4c23a88 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/JetTypeMapper.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/JetTypeMapper.java @@ -325,12 +325,12 @@ public class JetTypeMapper { //noinspection ConstantConditions return mapType(descriptor.getReturnType(), sw, TypeMappingMode.GENERIC_TYPE); } - else if (DescriptorUtils.isAnnotationClass(descriptor.getContainingDeclaration())) { - //noinspection ConstantConditions - return mapType(descriptor.getReturnType(), sw, TypeMappingMode.VALUE_FOR_ANNOTATION); - } else { - return mapType(returnType, sw, TypeMappingMode.DEFAULT, Variance.OUT_VARIANCE); + TypeMappingMode mappingMode = TypeMappingMode.getOptimalModeForReturnType( + returnType, + /* isAnnotationMethod = */ DescriptorUtils.isAnnotationClass(descriptor.getContainingDeclaration())); + + return mapType(returnType, sw, mappingMode); } } @@ -379,23 +379,17 @@ public class JetTypeMapper { return mapType(descriptor.getDefaultType()); } - @NotNull - private Type mapType(@NotNull KotlinType jetType, @Nullable BothSignatureWriter signatureVisitor, @NotNull TypeMappingMode mode) { - return mapType(jetType, signatureVisitor, mode, Variance.INVARIANT); - } - @NotNull private Type mapType( @NotNull KotlinType jetType, @Nullable BothSignatureWriter signatureVisitor, - @NotNull TypeMappingMode mode, - @NotNull Variance howThisTypeIsUsed + @NotNull TypeMappingMode mode ) { Type builtinType = mapBuiltinType(jetType); if (builtinType != null) { Type asmType = mode.getNeedPrimitiveBoxing() ? boxType(builtinType) : builtinType; - writeGenericType(jetType, asmType, signatureVisitor, howThisTypeIsUsed, mode); + writeGenericType(jetType, asmType, signatureVisitor, mode); return asmType; } @@ -440,7 +434,7 @@ public class JetTypeMapper { arrayElementType = boxType(mapType(memberType, mode)); if (signatureVisitor != null) { signatureVisitor.writeArrayType(); - mapType(memberType, signatureVisitor, mode.toGenericArgumentMode()); + mapType(memberType, signatureVisitor, mode.toGenericArgumentMode(memberProjection.getProjectionKind())); signatureVisitor.writeArrayEnd(); } } @@ -452,7 +446,7 @@ public class JetTypeMapper { Type asmType = mode.isForAnnotationParameter() && KotlinBuiltIns.isKClass((ClassDescriptor) descriptor) ? AsmTypes.JAVA_CLASS_TYPE : computeAsmType((ClassDescriptor) descriptor.getOriginal()); - writeGenericType(jetType, asmType, signatureVisitor, howThisTypeIsUsed, mode); + writeGenericType(jetType, asmType, signatureVisitor, mode); return asmType; } @@ -573,7 +567,6 @@ public class JetTypeMapper { @NotNull KotlinType type, @NotNull Type asmType, @Nullable BothSignatureWriter signatureVisitor, - @NotNull Variance howThisTypeIsUsed, @NotNull TypeMappingMode mode ) { if (signatureVisitor != null) { @@ -600,17 +593,14 @@ public class JetTypeMapper { writeGenericArguments( signatureVisitor, - outermostInnerType.getArguments(), outermostClass.getDeclaredTypeParameters(), - howThisTypeIsUsed, mode); + outermostInnerType.getArguments(), outermostClass.getDeclaredTypeParameters(), mode); for (PossiblyInnerType innerPart : innerTypesAsList.subList(1, innerTypesAsList.size())) { ClassDescriptor classDescriptor = innerPart.getClassDescriptor(); signatureVisitor.writeInnerClass(getJvmShortName(classDescriptor)); writeGenericArguments( signatureVisitor, innerPart.getArguments(), - classDescriptor.getDeclaredTypeParameters(), - howThisTypeIsUsed, mode - ); + classDescriptor.getDeclaredTypeParameters(), mode); } signatureVisitor.writeClassEnd(); @@ -631,7 +621,6 @@ public class JetTypeMapper { @NotNull BothSignatureWriter signatureVisitor, @NotNull List arguments, @NotNull List parameters, - @NotNull Variance howThisTypeIsUsed, @NotNull TypeMappingMode mode ) { for (Pair item : CollectionsKt.zip(parameters, arguments)) { @@ -642,11 +631,13 @@ public class JetTypeMapper { signatureVisitor.writeUnboundedWildcard(); } else { - Variance projectionKind = - getEffectiveVariance(parameter.getVariance(), argument.getProjectionKind(), howThisTypeIsUsed, mode); + Variance projectionKind = getVarianceForWildcard(parameter, argument, mode); signatureVisitor.writeTypeArgument(projectionKind); - mapType(argument.getType(), signatureVisitor, mode.toGenericArgumentMode()); + mapType(argument.getType(), signatureVisitor, + mode.toGenericArgumentMode( + TypeMappingUtil.getEffectiveVariance(parameter.getVariance(), argument.getProjectionKind()))); + signatureVisitor.writeTypeArgumentEnd(); } } @@ -670,21 +661,34 @@ public class JetTypeMapper { }); } - private static Variance getEffectiveVariance( - Variance parameterVariance, - Variance projectionKind, - Variance howThisTypeIsUsed, - TypeMappingMode mode + @NotNull + private static Variance getVarianceForWildcard( + @NotNull TypeParameterDescriptor parameter, + @NotNull TypeProjection projection, + @NotNull TypeMappingMode mode ) { - if (!mode.getWriteDeclarationSiteProjections() && projectionKind == Variance.INVARIANT) return Variance.INVARIANT; + Variance projectionKind = projection.getProjectionKind(); - // Return type must not contain wildcards - if (howThisTypeIsUsed == Variance.OUT_VARIANCE) return projectionKind; + if (mode.getSkipDeclarationSiteWildcards() && projectionKind == Variance.INVARIANT) { + return Variance.INVARIANT; + } + Variance parameterVariance = parameter.getVariance(); if (parameterVariance == Variance.INVARIANT) { return projectionKind; } + if (projectionKind == Variance.INVARIANT) { + if (mode.getSkipDeclarationSiteWildcardsIfPossible() && !projection.isStarProjection()) { + if (parameterVariance == Variance.OUT_VARIANCE && TypeMappingUtil.isMostPreciseCovariantArgument(projection.getType())){ + return Variance.INVARIANT; + } + + if (parameterVariance == Variance.IN_VARIANCE + && TypeMappingUtil.isMostPreciseContravariantArgument(projection.getType(), parameter)) { + return Variance.INVARIANT; + } + } return parameterVariance; } if (parameterVariance == projectionKind) { @@ -1187,7 +1191,7 @@ public class JetTypeMapper { private void writeParameter(@NotNull BothSignatureWriter sw, @NotNull JvmMethodParameterKind kind, @NotNull KotlinType type) { sw.writeParameterType(kind); - mapType(type, sw, TypeMappingMode.DEFAULT); + mapType(type, sw, TypeMappingMode.getOptimalModeForValueParameter(type)); sw.writeParameterTypeEnd(); } diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/TypeMappingMode.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/TypeMappingMode.kt index d49201eb347..b7c1974940b 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/TypeMappingMode.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/TypeMappingMode.kt @@ -16,11 +16,17 @@ package org.jetbrains.kotlin.codegen.state +import org.jetbrains.kotlin.types.KotlinType +import org.jetbrains.kotlin.types.Variance + internal class TypeMappingMode private constructor( val needPrimitiveBoxing: Boolean = false, val isForAnnotationParameter: Boolean = false, - val writeDeclarationSiteProjections: Boolean = true, - val genericArgumentMode: TypeMappingMode? = null + // Here DeclarationSiteWildcards means wildcard generated because of declaration-site variance + val skipDeclarationSiteWildcards: Boolean = false, + val skipDeclarationSiteWildcardsIfPossible: Boolean = false, + private val genericArgumentMode: TypeMappingMode? = null, + private val genericContravariantArgumentMode: TypeMappingMode? = genericArgumentMode ) { companion object { /** @@ -35,13 +41,12 @@ internal class TypeMappingMode private constructor( @JvmField val DEFAULT = TypeMappingMode(genericArgumentMode = GENERIC_TYPE) - /** * kotlin.Int is mapped to Ljava/lang/Integer; * No projections allowed in immediate arguments */ @JvmField - val SUPER_TYPE = TypeMappingMode(needPrimitiveBoxing = true, writeDeclarationSiteProjections = false, genericArgumentMode = GENERIC_TYPE) + val SUPER_TYPE = TypeMappingMode(needPrimitiveBoxing = true, skipDeclarationSiteWildcards = true, genericArgumentMode = GENERIC_TYPE) /** * kotlin.reflect.KClass mapped to java.lang.Class @@ -50,9 +55,49 @@ internal class TypeMappingMode private constructor( @JvmField val VALUE_FOR_ANNOTATION = TypeMappingMode( isForAnnotationParameter = true, - genericArgumentMode = TypeMappingMode(isForAnnotationParameter = true, needPrimitiveBoxing = true)) + genericArgumentMode = TypeMappingMode(isForAnnotationParameter = true, needPrimitiveBoxing = true, genericArgumentMode = GENERIC_TYPE)) + + @JvmStatic + fun getOptimalModeForValueParameter( + type: KotlinType + ) = getOptimalModeForSignaturePart(type, isForAnnotationParameter = false, canBeUsedInSupertypePosition = true) + + @JvmStatic + fun getOptimalModeForReturnType( + type: KotlinType, + isAnnotationMethod: Boolean + ) = getOptimalModeForSignaturePart(type, isForAnnotationParameter = isAnnotationMethod, canBeUsedInSupertypePosition = false) + + private fun getOptimalModeForSignaturePart( + type: KotlinType, + isForAnnotationParameter: Boolean, + canBeUsedInSupertypePosition: Boolean + ): TypeMappingMode { + if (type.arguments.isEmpty()) return DEFAULT + + val contravariantArgumentMode = + if (!canBeUsedInSupertypePosition) + TypeMappingMode( + needPrimitiveBoxing = true, + isForAnnotationParameter = isForAnnotationParameter, + skipDeclarationSiteWildcards = false, + skipDeclarationSiteWildcardsIfPossible = true) + else + null + + return TypeMappingMode( + needPrimitiveBoxing = true, + isForAnnotationParameter = isForAnnotationParameter, + skipDeclarationSiteWildcards = !canBeUsedInSupertypePosition, + skipDeclarationSiteWildcardsIfPossible = true, + genericContravariantArgumentMode = contravariantArgumentMode) + } } - fun toGenericArgumentMode(): TypeMappingMode = genericArgumentMode ?: this + fun toGenericArgumentMode(effectiveVariance: Variance): TypeMappingMode = + when (effectiveVariance) { + Variance.IN_VARIANCE -> genericContravariantArgumentMode ?: this + else -> genericArgumentMode ?: this + } } diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/typeMappingUtil.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/typeMappingUtil.kt new file mode 100644 index 00000000000..f0389b82211 --- /dev/null +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/typeMappingUtil.kt @@ -0,0 +1,69 @@ +/* + * 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. + */ + +@file:JvmName("TypeMappingUtil") +package org.jetbrains.kotlin.codegen.state + +import org.jetbrains.kotlin.builtins.KotlinBuiltIns +import org.jetbrains.kotlin.descriptors.ClassDescriptor +import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor +import org.jetbrains.kotlin.types.KotlinType +import org.jetbrains.kotlin.types.Variance + +fun KotlinType.isMostPreciseContravariantArgument(parameter: TypeParameterDescriptor): Boolean = + // TODO: probably class upper bound should be used + KotlinBuiltIns.isAnyOrNullableAny(this) + +fun KotlinType.isMostPreciseCovariantArgument(): Boolean = !canHaveSubtypesIgnoringNullability() + +private fun KotlinType.canHaveSubtypesIgnoringNullability(): Boolean { + val constructor = constructor + val descriptor = constructor.declarationDescriptor + + when (descriptor) { + is TypeParameterDescriptor -> return true + is ClassDescriptor -> if (descriptor.modality.isOverridable) return true + } + + for ((parameter, argument) in constructor.parameters.zip(arguments)) { + if (argument.isStarProjection) return true + val projectionKind = argument.projectionKind + val type = argument.type + + val effectiveVariance = getEffectiveVariance(parameter.variance, projectionKind) + if (effectiveVariance == Variance.OUT_VARIANCE && !type.isMostPreciseCovariantArgument()) return true + if (effectiveVariance == Variance.IN_VARIANCE && !type.isMostPreciseContravariantArgument(parameter)) return true + } + + return false +} + +public fun getEffectiveVariance(parameterVariance: Variance, projectionKind: Variance): Variance { + if (parameterVariance === Variance.INVARIANT) { + return projectionKind + } + if (projectionKind === Variance.INVARIANT) { + return parameterVariance + } + if (parameterVariance === projectionKind) { + return parameterVariance + } + + // In = In<*> + // Out = Out<*> + return Variance.OUT_VARIANCE +} + diff --git a/compiler/testData/codegen/boxWithStdlib/reflection/genericSignature/covariantOverride.kt b/compiler/testData/codegen/boxWithStdlib/reflection/genericSignature/covariantOverride.kt new file mode 100644 index 00000000000..e49c7ae13b3 --- /dev/null +++ b/compiler/testData/codegen/boxWithStdlib/reflection/genericSignature/covariantOverride.kt @@ -0,0 +1,16 @@ +interface A { + fun foo(): Collection +} + +abstract class B : A { + override fun foo(): Collection = null!! +} + +fun box(): String { + val clazz = B::class.java + if (clazz.declaredMethods.first().genericReturnType.toString() != "java.util.Collection") return "fail 1" + + if (clazz.methods.filter { it.name == "foo" }.size != 1) return "fail 2" + + return "OK" +} diff --git a/compiler/testData/writeSignature/constructor/ConstructorCollectionParameter.kt b/compiler/testData/writeSignature/constructor/ConstructorCollectionParameter.kt index b2c95535483..503fc97488f 100644 --- a/compiler/testData/writeSignature/constructor/ConstructorCollectionParameter.kt +++ b/compiler/testData/writeSignature/constructor/ConstructorCollectionParameter.kt @@ -3,4 +3,4 @@ class TestingKotlinCollections(val arguments: Collection) // method: TestingKotlinCollections:: // jvm signature: (Ljava/util/Collection;)V -// generic signature: (Ljava/util/Collection<+Ljava/lang/String;>;)V +// generic signature: (Ljava/util/Collection;)V diff --git a/compiler/testData/writeSignature/declarationSiteVariance/FunctionTwoTypeParameters.kt b/compiler/testData/writeSignature/declarationSiteVariance/FunctionTwoTypeParameters.kt index 3c63408c4e9..22fbfd267d9 100644 --- a/compiler/testData/writeSignature/declarationSiteVariance/FunctionTwoTypeParameters.kt +++ b/compiler/testData/writeSignature/declarationSiteVariance/FunctionTwoTypeParameters.kt @@ -6,4 +6,4 @@ fun f(m: M): M = throw Exception() // method: FunctionTwoTypeParametersKt::f // jvm signature: (LM;)LM; -// generic signature: (LM<-LX;+LX;>;)LM; \ No newline at end of file +// generic signature: (LM<-LX;LX;>;)LM; \ No newline at end of file diff --git a/compiler/testData/writeSignature/declarationSiteVariance/GenericOverrides.kt b/compiler/testData/writeSignature/declarationSiteVariance/GenericOverrides.kt new file mode 100644 index 00000000000..2dea3eb86af --- /dev/null +++ b/compiler/testData/writeSignature/declarationSiteVariance/GenericOverrides.kt @@ -0,0 +1,40 @@ +class Out +class In + +interface A { + fun foo1(x: Out): Out + fun foo2(x: In): In + + var prop: Out +} + +// method: A::foo1 +// generic signature: (LOut<+TT;>;)LOut; + +// method: A::foo2 +// generic signature: (LIn<-TE;>;)LIn; + +// method: A::getProp +// generic signature: ()LOut; + +// method: A::setProp +// generic signature: (LOut<+TT;>;)V + +abstract class B : A { + override final fun foo1(x: Out): Out = null!! + override final fun foo2(x: In): In = null!! + + override final var prop: Out = null!! +} + +// method: B::foo1 +// generic signature: (LOut;)LOut; + +// method: B::foo2 +// generic signature: (LIn;)LIn; + +// method: B::getProp +// generic signature: ()LOut; + +// method: B::setProp +// generic signature: (LOut;)V diff --git a/compiler/testData/writeSignature/declarationSiteVariance/InOfOutInInPosition.kt b/compiler/testData/writeSignature/declarationSiteVariance/InOfOutInInPosition.kt index ba4bd7e0f09..ac2738b360e 100644 --- a/compiler/testData/writeSignature/declarationSiteVariance/InOfOutInInPosition.kt +++ b/compiler/testData/writeSignature/declarationSiteVariance/InOfOutInInPosition.kt @@ -6,4 +6,4 @@ fun f(p: In>) {} // method: InOfOutInInPositionKt::f // jvm signature: (LIn;)V -// generic signature: (LIn<-LOut<+LX;>;>;)V \ No newline at end of file +// generic signature: (LIn<-LOut;>;)V \ No newline at end of file diff --git a/compiler/testData/writeSignature/declarationSiteVariance/InOfOutInOutPosition.kt b/compiler/testData/writeSignature/declarationSiteVariance/InOfOutInOutPosition.kt index 4a0304dd00b..8845840556d 100644 --- a/compiler/testData/writeSignature/declarationSiteVariance/InOfOutInOutPosition.kt +++ b/compiler/testData/writeSignature/declarationSiteVariance/InOfOutInOutPosition.kt @@ -6,4 +6,4 @@ fun f(): In> = throw Exception() // method: InOfOutInOutPositionKt::f // jvm signature: ()LIn; -// generic signature: ()LIn;>; \ No newline at end of file +// generic signature: ()LIn;>; \ No newline at end of file diff --git a/compiler/testData/writeSignature/declarationSiteVariance/OpenMembersReturnType.kt b/compiler/testData/writeSignature/declarationSiteVariance/OpenMembersReturnType.kt new file mode 100644 index 00000000000..befa5e851cb --- /dev/null +++ b/compiler/testData/writeSignature/declarationSiteVariance/OpenMembersReturnType.kt @@ -0,0 +1,51 @@ +class OutPair +class In + +interface A { + fun foo1(): OutPair + fun foo2(): OutPair + fun foo3(): OutPair, Number> + + fun foo4(): In + fun foo5(): In + + val prop1: OutPair + val prop2: OutPair +} + +// method: A::foo1 +// generic signature: ()LOutPair; + +// method: A::foo2 +// generic signature: ()LOutPair; + +// method: A::foo3 +// generic signature: ()LOutPair;Ljava/lang/Number;>; + +// method: A::foo4 +// generic signature: ()LIn; + +// method: A::foo5 +// generic signature: ()LIn; + +// method: A::getProp1 +// generic signature: ()LOutPair; + +// method: A::getProp2 +// generic signature: ()LOutPair; + +abstract class B : A { + override fun foo2(): OutPair = null!! + override fun foo3(): OutPair, Int> = null!! + + override val prop2: OutPair = null!! +} + +// method: B::foo2 +// generic signature: ()LOutPair; + +// method: B::foo3 +// generic signature: ()LOutPair;Ljava/lang/Integer;>; + +// method: B::getProp2 +// generic signature: ()LOutPair; \ No newline at end of file diff --git a/compiler/testData/writeSignature/declarationSiteVariance/OpenMembersValueParameter.kt b/compiler/testData/writeSignature/declarationSiteVariance/OpenMembersValueParameter.kt new file mode 100644 index 00000000000..8724818b5f6 --- /dev/null +++ b/compiler/testData/writeSignature/declarationSiteVariance/OpenMembersValueParameter.kt @@ -0,0 +1,58 @@ +class OutPair +class In + +interface A { + fun foo1(x: OutPair) + fun foo2(x: OutPair) + + fun foo3(x: In) + fun foo4(x: In) + + var prop1: OutPair +} + +// method: A::foo1 +// generic signature: (LOutPair;)V + +// method: A::foo2 +// generic signature: (LOutPair<+Ljava/lang/CharSequence;Ljava/lang/Integer;>;)V + +// method: A::foo3 +// generic signature: (LIn<-Ljava/lang/String;>;)V + +// method: A::foo4 +// generic signature: (LIn;)V + +// method: A::getProp1 +// generic signature: ()LOutPair; + +// method: A::setProp1 +// generic signature: (LOutPair;)V + +abstract class B : A { + override final fun foo1(x: OutPair) {} + override final fun foo2(x: OutPair) {} + + override final fun foo3(x: In) {} + override final fun foo4(x: In) {} + + override final var prop1: OutPair = null!! +} + +// method: B::foo1 +// generic signature: (LOutPair;)V + +// method: B::foo2 +// generic signature: (LOutPair<+Ljava/lang/CharSequence;Ljava/lang/Integer;>;)V + +// method: B::foo3 +// generic signature: (LIn<-Ljava/lang/String;>;)V + +// method: B::foo4 +// generic signature: (LIn;)V + +// method: B::getProp1 +// generic signature: ()LOutPair; + +// method: A::setProp1 +// generic signature: (LOutPair;)V diff --git a/compiler/testData/writeSignature/declarationSiteVariance/OutInInPosition.kt b/compiler/testData/writeSignature/declarationSiteVariance/OutInInPosition.kt index de45c33270a..d05bb07c992 100644 --- a/compiler/testData/writeSignature/declarationSiteVariance/OutInInPosition.kt +++ b/compiler/testData/writeSignature/declarationSiteVariance/OutInInPosition.kt @@ -2,4 +2,4 @@ fun f(p: List) {} // method: OutInInPositionKt::f // jvm signature: (Ljava/util/List;)V -// generic signature: (Ljava/util/List<+Ljava/lang/String;>;)V \ No newline at end of file +// generic signature: (Ljava/util/List;)V \ No newline at end of file diff --git a/compiler/testData/writeSignature/declarationSiteVariance/OutOfInInOutPosition.kt b/compiler/testData/writeSignature/declarationSiteVariance/OutOfInInOutPosition.kt index aa975b65162..681a92584d2 100644 --- a/compiler/testData/writeSignature/declarationSiteVariance/OutOfInInOutPosition.kt +++ b/compiler/testData/writeSignature/declarationSiteVariance/OutOfInInOutPosition.kt @@ -6,4 +6,4 @@ fun f(): Out> = throw Exception() // method: OutOfInInOutPositionKt::f // jvm signature: ()LOut; -// generic signature: ()LOut;>; \ No newline at end of file +// generic signature: ()LOut;>; \ No newline at end of file diff --git a/compiler/testData/writeSignature/declarationSiteVariance/OutOfOutInInPosition.kt b/compiler/testData/writeSignature/declarationSiteVariance/OutOfOutInInPosition.kt index 975a838160d..dde9c42c2b2 100644 --- a/compiler/testData/writeSignature/declarationSiteVariance/OutOfOutInInPosition.kt +++ b/compiler/testData/writeSignature/declarationSiteVariance/OutOfOutInInPosition.kt @@ -5,4 +5,4 @@ fun f(p: Out>) {} // method: OutOfOutInInPositionKt::f // jvm signature: (LOut;)V -// generic signature: (LOut<+LOut<+LX;>;>;)V \ No newline at end of file +// generic signature: (LOut;>;)V \ No newline at end of file diff --git a/compiler/testData/writeSignature/declarationSiteVariance/OutOfOutInOutPosition.kt b/compiler/testData/writeSignature/declarationSiteVariance/OutOfOutInOutPosition.kt index 8a053005788..b5b2ff30b4f 100644 --- a/compiler/testData/writeSignature/declarationSiteVariance/OutOfOutInOutPosition.kt +++ b/compiler/testData/writeSignature/declarationSiteVariance/OutOfOutInOutPosition.kt @@ -1,18 +1,15 @@ class Out class X -// Why we want this to be translated to 'Out> f()' instead of 'Out> f()' -// There are two instantiations of 'In' in this test: outer Out<...> and inner Out -// So why do we want to put a wildcard on the inner one and not the outer? -// People don't want wildcards in return types, because they are _long_. So we try our best to remove wildcards where possible -// Not putting a wildcard on the outer occurrence is not imposing a restriction, actually it is removing one: -// anything that can be done with Out in Java can be done with Out -// But omitting the wildcard on the inner occurrence is restrictive: -// one can add a List to a List>, -// but not to a List>, -// thus removing the wildcard would be restricting the use of the return value of the method, and we don't want do this. +// Why we want this to be translated to 'Out> f()' instead of 'Out> f()' +// For return types default behaviour is skipping all declaration-site wildcards. +// The intuition behind this rule is simple: return types are basically used in subtype position +// (as an argument for another call), and here everything works well in case of 'out'-variance. +// For example we have 'Out>>' as subtype both for 'Out>>' and 'Out>>', +// so values of such type is more flexible in contrast to `Out>>` that could be used only +// for the second case. fun f(): Out> = throw Exception() // method: OutOfOutInOutPositionKt::f // jvm signature: ()LOut; -// generic signature: ()LOut;>; \ No newline at end of file +// generic signature: ()LOut;>; \ No newline at end of file diff --git a/compiler/testData/writeSignature/declarationSiteVariance/PropertySetterOut.kt b/compiler/testData/writeSignature/declarationSiteVariance/PropertySetterOut.kt index 064cfb223e2..54069a5240f 100644 --- a/compiler/testData/writeSignature/declarationSiteVariance/PropertySetterOut.kt +++ b/compiler/testData/writeSignature/declarationSiteVariance/PropertySetterOut.kt @@ -5,4 +5,4 @@ var p: M = throw Exception() // method: PropertySetterOutKt::setP // jvm signature: (LM;)V -// generic signature: (LM<+LX;>;)V \ No newline at end of file +// generic signature: (LM;)V \ No newline at end of file diff --git a/compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization/argumentOverridability.kt b/compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization/argumentOverridability.kt new file mode 100644 index 00000000000..a14a49f67c0 --- /dev/null +++ b/compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization/argumentOverridability.kt @@ -0,0 +1,25 @@ +class Out +class OutPair +class In + +class Final +open class Open + +// For value parameters we decided to skip wildcards if it doesn't make obtained signature weaker +// in a sense of set of acceptable arguments. +// More precisely: +//    a. We write wildcard for 'Out' iff T ``can have subtypes ignoring nullability'' +//    b. We write wildcard for 'In' iff T is not equal to it's class upper bound (ignoring nullability again) +// Definition of ``can have subtypes ignoring nullability'' is straightforward and you can see it in commit. + +fun openClassArgument(x: Out, y: In) {} +// method: ArgumentOverridabilityKt::openClassArgument +// generic signature: (LOut<+LOpen;>;LIn<-LOpen;>;)V + +fun finalClassArgument(x: Out, y: In) {} +// method: ArgumentOverridabilityKt::finalClassArgument +// generic signature: (LOut;LIn<-LFinal;>;)V + +fun oneArgumentFinal(x: OutPair) {} +// method: ArgumentOverridabilityKt::oneArgumentFinal +// generic signature: (LOutPair;)V diff --git a/compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization/arrays.kt b/compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization/arrays.kt new file mode 100644 index 00000000000..56d05c125da --- /dev/null +++ b/compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization/arrays.kt @@ -0,0 +1,23 @@ +class Inv +class Out +class OutPair +class In + +class Final +open class Open + +fun arrayOfOutOpen(x: Array>) {} +// method: ArraysKt::arrayOfOutOpen +// generic signature: ([LOut<+LOpen;>;)V + +fun arrayOfOutFinal(x: Array>) {} +// method: ArraysKt::arrayOfOutFinal +// generic signature: ([LOut;)V + +fun outOfArrayOpen(x: Out>) {} +// method: ArraysKt::outOfArrayOpen +// generic signature: (LOut<[LOpen;>;)V + +fun outOfArrayOutOpen(x: Out>) {} +// method: ArraysKt::outOfArrayOutOpen +// generic signature: (LOut<+[LOpen;>;)V diff --git a/compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization/complicatedInBounds.kt b/compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization/complicatedInBounds.kt new file mode 100644 index 00000000000..213280dfd9f --- /dev/null +++ b/compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization/complicatedInBounds.kt @@ -0,0 +1,12 @@ +class Out +class In + +fun optimized(x: In) {} +// method: ComplicatedInBoundsKt::optimized +// generic signature: (LIn<-Ljava/lang/CharSequence;Ljava/lang/CharSequence;>;)V + +class In2> + +fun nonOptimized(x: In2, *>) {} +// method: ComplicatedInBoundsKt::nonOptimized +// generic signature: (LIn2<-LIn2<**>;*>;)V diff --git a/compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization/deepOut.kt b/compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization/deepOut.kt new file mode 100644 index 00000000000..ae4f16aeb7c --- /dev/null +++ b/compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization/deepOut.kt @@ -0,0 +1,12 @@ +class Out + +class Final +open class Open + +fun deepOpen(x: Out>>) {} +// method: DeepOutKt::deepOpen +// generic signature: (LOut<+LOut<+LOut<+LOpen;>;>;>;)V + +fun deepFinal(x: Out>>) {} +// method: DeepOutKt::deepFinal +// generic signature: (LOut;>;>;)V diff --git a/compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization/finalReturnType.kt b/compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization/finalReturnType.kt new file mode 100644 index 00000000000..60ce5ef71f3 --- /dev/null +++ b/compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization/finalReturnType.kt @@ -0,0 +1,31 @@ +class Out +class OutPair +class In +class Inv + +open class Open +class Final + +fun skipAllOutInvWildcards(): Inv>>> = null!! +// method: FinalReturnTypeKt::skipAllOutInvWildcards +// generic signature: ()LInv;>;>;>; + +fun notDeepIn(): In = null!! +// method: FinalReturnTypeKt::notDeepIn +// generic signature: ()LIn; + +fun skipWildcardsUntilIn0(): Out>> = null!! +// method: FinalReturnTypeKt::skipWildcardsUntilIn0 +// generic signature: ()LOut;>;>; + +fun skipWildcardsUntilIn1(): Out>> = null!! +// method: FinalReturnTypeKt::skipWildcardsUntilIn1 +// generic signature: ()LOut;>;>; + +fun skipWildcardsUntilIn2(): Out>>> = null!! +// method: FinalReturnTypeKt::skipWildcardsUntilIn2 +// generic signature: ()LOut;>;>;>; + +fun skipWildcardsUntilInProjection(): Inv> = null!! +// method: FinalReturnTypeKt::skipWildcardsUntilInProjection +// generic signature: ()LInv<-LOut<+LOpen;>;>; diff --git a/compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization/outIn.kt b/compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization/outIn.kt new file mode 100644 index 00000000000..17e937f48ec --- /dev/null +++ b/compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization/outIn.kt @@ -0,0 +1,12 @@ +class Out +class In + +class Final + +fun outIn(x: Out>) {} +// method: OutInKt::outIn +// generic signature: (LOut<+LIn<-LFinal;>;>;)V + +fun outInAny(x: Out>) {} +// method: OutInKt::outInAny +// generic signature: (LOut;>;)V diff --git a/compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization/outInv.kt b/compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization/outInv.kt new file mode 100644 index 00000000000..3802fcc12e9 --- /dev/null +++ b/compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization/outInv.kt @@ -0,0 +1,25 @@ +class Inv +class Out + +class Final +open class Open + +fun invInv(x: Out>) {} +// method: OutInvKt::invInv +// generic signature: (LOut;>;)V + +fun invOut(x: Out>) {} +// method: OutInvKt::invOut +// generic signature: (LOut<+LInv<+LOpen;>;>;)V + +fun invOutFinal(x: Out>) {} +// method: OutInvKt::invOutFinal +// generic signature: (LOut;>;)V + +fun invIn(x: Out>) {} +// method: OutInvKt::invIn +// generic signature: (LOut<+LInv<-LFinal;>;>;)V + +fun invInAny(x: Out>) {} +// method: OutInvKt::invInAny +// generic signature: (LOut;>;)V diff --git a/compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization/topLevelIn.kt b/compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization/topLevelIn.kt new file mode 100644 index 00000000000..063df297b09 --- /dev/null +++ b/compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization/topLevelIn.kt @@ -0,0 +1,15 @@ +class In +class Out +class Final + +fun inFinal(x: In) {} +// method: TopLevelInKt::inFinal +// generic signature: (LIn<-LFinal;>;)V + +fun inAny(x: In) {} +// method: TopLevelInKt::inAny +// generic signature: (LIn;)V + +fun inOutFinal(x: In>) {} +// method: TopLevelInKt::inOutFinal +// generic signature: (LIn<-LOut;>;)V diff --git a/compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization/topLevelInv.kt b/compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization/topLevelInv.kt new file mode 100644 index 00000000000..b83b6b94188 --- /dev/null +++ b/compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization/topLevelInv.kt @@ -0,0 +1,24 @@ +class Inv +class Out +class Final +open class Open + +fun invOpen(x: Inv) {} +// method: TopLevelInvKt::invOpen +// generic signature: (LInv;)V + +fun invFinal(x: Inv) {} +// method: TopLevelInvKt::invFinal +// generic signature: (LInv;)V + +fun invOutOpen(x: Inv>) {} +// method: TopLevelInvKt::invOutOpen +// generic signature: (LInv;>;)V + +fun invOutFinal(x: Inv>) {} +// method: TopLevelInvKt::invOutFinal +// generic signature: (LInv;>;)V + +fun invOutProjectedOutFinal(x: Inv>) {} +// method: TopLevelInvKt::invOutProjectedOutFinal +// generic signature: (LInv<+LOut;>;)V diff --git a/compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization/typeParameter.kt b/compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization/typeParameter.kt new file mode 100644 index 00000000000..67f29d43fbe --- /dev/null +++ b/compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization/typeParameter.kt @@ -0,0 +1,8 @@ +class Out +class In + +class Final + +fun typeParameter(x: Out, y: In) {} +// method: TypeParameterKt::typeParameter +// generic signature: (LOut<+TQ;>;LIn<-TQ;>;)V diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/generated/BlackBoxWithStdlibCodegenTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/codegen/generated/BlackBoxWithStdlibCodegenTestGenerated.java index 318d659cd36..697dfc2bd6b 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/generated/BlackBoxWithStdlibCodegenTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/generated/BlackBoxWithStdlibCodegenTestGenerated.java @@ -3696,6 +3696,12 @@ public class BlackBoxWithStdlibCodegenTestGenerated extends AbstractBlackBoxCode KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/boxWithStdlib/reflection/genericSignature"), Pattern.compile("^(.+)\\.kt$"), true); } + @TestMetadata("covariantOverride.kt") + public void testCovariantOverride() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/boxWithStdlib/reflection/genericSignature/covariantOverride.kt"); + doTestWithStdlib(fileName); + } + @TestMetadata("kt5112.kt") public void testKt5112() throws Exception { String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/boxWithStdlib/reflection/genericSignature/kt5112.kt"); diff --git a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/WriteSignatureTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/WriteSignatureTestGenerated.java index 3cb77950f9e..d177a9cd4cd 100644 --- a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/WriteSignatureTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/WriteSignatureTestGenerated.java @@ -223,6 +223,12 @@ public class WriteSignatureTestGenerated extends AbstractWriteSignatureTest { doTest(fileName); } + @TestMetadata("GenericOverrides.kt") + public void testGenericOverrides() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/declarationSiteVariance/GenericOverrides.kt"); + doTest(fileName); + } + @TestMetadata("InInInPosition.kt") public void testInInInPosition() throws Exception { String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/declarationSiteVariance/InInInPosition.kt"); @@ -265,6 +271,18 @@ public class WriteSignatureTestGenerated extends AbstractWriteSignatureTest { doTest(fileName); } + @TestMetadata("OpenMembersReturnType.kt") + public void testOpenMembersReturnType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/declarationSiteVariance/OpenMembersReturnType.kt"); + doTest(fileName); + } + + @TestMetadata("OpenMembersValueParameter.kt") + public void testOpenMembersValueParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/declarationSiteVariance/OpenMembersValueParameter.kt"); + doTest(fileName); + } + @TestMetadata("OutInField.kt") public void testOutInField() throws Exception { String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/declarationSiteVariance/OutInField.kt"); @@ -354,6 +372,75 @@ public class WriteSignatureTestGenerated extends AbstractWriteSignatureTest { String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/declarationSiteVariance/SuperTypeWithVarianceInArguments.kt"); doTest(fileName); } + + @TestMetadata("compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class WildcardOptimization extends AbstractWriteSignatureTest { + public void testAllFilesPresentInWildcardOptimization() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("argumentOverridability.kt") + public void testArgumentOverridability() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization/argumentOverridability.kt"); + doTest(fileName); + } + + @TestMetadata("arrays.kt") + public void testArrays() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization/arrays.kt"); + doTest(fileName); + } + + @TestMetadata("complicatedInBounds.kt") + public void testComplicatedInBounds() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization/complicatedInBounds.kt"); + doTest(fileName); + } + + @TestMetadata("deepOut.kt") + public void testDeepOut() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization/deepOut.kt"); + doTest(fileName); + } + + @TestMetadata("finalReturnType.kt") + public void testFinalReturnType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization/finalReturnType.kt"); + doTest(fileName); + } + + @TestMetadata("outIn.kt") + public void testOutIn() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization/outIn.kt"); + doTest(fileName); + } + + @TestMetadata("outInv.kt") + public void testOutInv() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization/outInv.kt"); + doTest(fileName); + } + + @TestMetadata("topLevelIn.kt") + public void testTopLevelIn() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization/topLevelIn.kt"); + doTest(fileName); + } + + @TestMetadata("topLevelInv.kt") + public void testTopLevelInv() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization/topLevelInv.kt"); + doTest(fileName); + } + + @TestMetadata("typeParameter.kt") + public void testTypeParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization/typeParameter.kt"); + doTest(fileName); + } + } } @TestMetadata("compiler/testData/writeSignature/nothing") diff --git a/j2k/testData/fileOrElement/mutableCollections/Overrides.java b/j2k/testData/fileOrElement/mutableCollections/Overrides.java index 5d73af7104b..92660d21d05 100644 --- a/j2k/testData/fileOrElement/mutableCollections/Overrides.java +++ b/j2k/testData/fileOrElement/mutableCollections/Overrides.java @@ -10,7 +10,7 @@ public abstract class C extends KotlinClass { super(field); } - public List foo(Collection mutableCollection, Collection nullableCollection) { + public List foo(Collection mutableCollection, Collection nullableCollection) { return super.foo(mutableCollection, nullableCollection); } }