From fb900d2e2a85e927dbf6ef833214fa974ffde677 Mon Sep 17 00:00:00 2001 From: Alexander Udalov Date: Fri, 12 May 2023 10:50:07 +0200 Subject: [PATCH] JVM: remove most usages of JvmTarget.JVM_1_6 --- .../kotlin/codegen/AnnotationCodegen.java | 39 +++------ .../kotlin/codegen/DescriptorAsmUtil.java | 27 +----- .../kotlin/codegen/intrinsics/CompareTo.kt | 10 +-- .../kotlin/codegen/intrinsics/HashCode.kt | 5 +- .../codegen/intrinsics/IntrinsicMethods.java | 52 ++++++------ .../kotlin/codegen/state/GenerationState.kt | 33 ++++---- .../kotlin/codegen/state/KotlinTypeMapper.kt | 3 +- .../jetbrains/kotlin/cli/jvm/jvmArguments.kt | 42 +++------- .../config/JvmClosureGenerationScheme.kt | 11 +-- .../backend/jvm/codegen/AnnotationCodegen.kt | 82 +++++++++---------- .../backend/jvm/intrinsics/CompareTo.kt | 14 +--- .../kotlin/backend/jvm/intrinsics/HashCode.kt | 3 +- .../backend/jvm/lower/JvmBuiltInsLowering.kt | 26 +++--- .../KtLightModifierListDescriptorBased.kt | 2 +- .../elements/KtToJvmAnnotationsConverter.kt | 21 ++--- .../kotlin/test/util/KtTestUtil.java | 5 -- .../backend/classic/JavaCompilerFacade.kt | 4 +- .../kotlin/codegen/CodegenTestUtil.java | 2 +- .../kotlin/jvm/repl/ReplCompilerJava8Test.kt | 1 - .../JvmVersionRequirementTest.kt | 1 - 20 files changed, 137 insertions(+), 246 deletions(-) diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/AnnotationCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/AnnotationCodegen.java index d3f577c0f09..63e600177f0 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/AnnotationCodegen.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/AnnotationCodegen.java @@ -22,7 +22,6 @@ import org.jetbrains.annotations.Nullable; import org.jetbrains.kotlin.codegen.state.GenerationState; import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper; import org.jetbrains.kotlin.config.JVMConfigurationKeys; -import org.jetbrains.kotlin.config.JvmTarget; import org.jetbrains.kotlin.descriptors.*; import org.jetbrains.kotlin.descriptors.annotations.*; import org.jetbrains.kotlin.descriptors.impl.AnonymousFunctionDescriptor; @@ -262,30 +261,20 @@ public abstract class AnnotationCodegen { ); } - private static final Map> annotationTargetMaps = new EnumMap<>(JvmTarget.class); + private static final Map annotationTargetMap = new EnumMap<>(KotlinTarget.class); static { - Map jvm6 = new EnumMap<>(KotlinTarget.class); - jvm6.put(KotlinTarget.CLASS, ElementType.TYPE); - jvm6.put(KotlinTarget.ANNOTATION_CLASS, ElementType.ANNOTATION_TYPE); - jvm6.put(KotlinTarget.CONSTRUCTOR, ElementType.CONSTRUCTOR); - jvm6.put(KotlinTarget.LOCAL_VARIABLE, ElementType.LOCAL_VARIABLE); - jvm6.put(KotlinTarget.FUNCTION, ElementType.METHOD); - jvm6.put(KotlinTarget.PROPERTY_GETTER, ElementType.METHOD); - jvm6.put(KotlinTarget.PROPERTY_SETTER, ElementType.METHOD); - jvm6.put(KotlinTarget.FIELD, ElementType.FIELD); - jvm6.put(KotlinTarget.VALUE_PARAMETER, ElementType.PARAMETER); - - Map jvm8 = new EnumMap<>(jvm6); - jvm8.put(KotlinTarget.TYPE_PARAMETER, ElementType.TYPE_PARAMETER); - jvm8.put(KotlinTarget.TYPE, ElementType.TYPE_USE); - - annotationTargetMaps.put(JvmTarget.JVM_1_6, jvm6); - for (JvmTarget target : JvmTarget.values()) { - if (target != JvmTarget.JVM_1_6) { - annotationTargetMaps.put(target, jvm8); - } - } + annotationTargetMap.put(KotlinTarget.CLASS, ElementType.TYPE); + annotationTargetMap.put(KotlinTarget.ANNOTATION_CLASS, ElementType.ANNOTATION_TYPE); + annotationTargetMap.put(KotlinTarget.CONSTRUCTOR, ElementType.CONSTRUCTOR); + annotationTargetMap.put(KotlinTarget.LOCAL_VARIABLE, ElementType.LOCAL_VARIABLE); + annotationTargetMap.put(KotlinTarget.FUNCTION, ElementType.METHOD); + annotationTargetMap.put(KotlinTarget.PROPERTY_GETTER, ElementType.METHOD); + annotationTargetMap.put(KotlinTarget.PROPERTY_SETTER, ElementType.METHOD); + annotationTargetMap.put(KotlinTarget.FIELD, ElementType.FIELD); + annotationTargetMap.put(KotlinTarget.VALUE_PARAMETER, ElementType.PARAMETER); + annotationTargetMap.put(KotlinTarget.TYPE_PARAMETER, ElementType.TYPE_PARAMETER); + annotationTargetMap.put(KotlinTarget.TYPE, ElementType.TYPE_USE); } private void generateTargetAnnotation( @@ -294,9 +283,6 @@ public abstract class AnnotationCodegen { String descriptor = Type.getType(Target.class).getDescriptor(); if (!annotationDescriptorsAlreadyPresent.add(descriptor)) return; - Map annotationTargetMap = annotationTargetMaps.get(typeMapper.getJvmTarget()); - if (annotationTargetMap == null) throw new AssertionError("No annotation target map for JVM target " + typeMapper.getJvmTarget()); - Set targets = AnnotationChecker.Companion.applicableTargetSetFromTargetAnnotationOrNull(classDescriptor); Set javaTargets; if (targets == null) { @@ -730,7 +716,6 @@ public abstract class AnnotationCodegen { private void generateTypeAnnotations(@NotNull Annotated annotated, @Nullable KotlinType type) { if (isAccessor(annotated) || type == null || - state.getTarget() == JvmTarget.JVM_1_6 || !state.getConfiguration().getBoolean(JVMConfigurationKeys.EMIT_JVM_TYPE_ANNOTATIONS)) { return; } diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/DescriptorAsmUtil.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/DescriptorAsmUtil.java index e494ab1b287..b2b467be99a 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/DescriptorAsmUtil.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/DescriptorAsmUtil.java @@ -52,7 +52,6 @@ import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter; import java.util.ArrayList; import java.util.List; -import static org.jetbrains.kotlin.builtins.KotlinBuiltIns.isBoolean; import static org.jetbrains.kotlin.codegen.AsmUtil.*; import static org.jetbrains.kotlin.codegen.CodegenUtilKt.isToArrayFromCollection; import static org.jetbrains.kotlin.codegen.JvmCodegenUtil.isConstOrHasJvmFieldAnnotation; @@ -598,34 +597,10 @@ public class DescriptorAsmUtil { iv.mark(end); } else { - if (JvmTarget.JVM_1_6 == jvmTarget) { - if (type.getSort() == Type.LONG) { - genLongHashCode(mv, iv); - } - else if (type.getSort() == Type.DOUBLE) { - iv.invokestatic("java/lang/Double", "doubleToLongBits", "(D)J", false); - genLongHashCode(mv, iv); - } - else if (type.getSort() == Type.FLOAT) { - iv.invokestatic("java/lang/Float", "floatToIntBits", "(F)I", false); - } - else { // byte short char int - // do nothing - } - } else { - HashCode.Companion.invokeHashCode(iv, type); - } + HashCode.Companion.invokeHashCode(iv, type); } } - private static void genLongHashCode(MethodVisitor mv, InstructionAdapter iv) { - iv.dup2(); - iv.iconst(32); - iv.ushr(Type.LONG_TYPE); - iv.xor(Type.LONG_TYPE); - mv.visitInsn(L2I); - } - @NotNull public static StackValue genEqualsForExpressionsOnStack( @NotNull IElementType opToken, diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/intrinsics/CompareTo.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/intrinsics/CompareTo.kt index d8c740ded3b..23eae021ff0 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/intrinsics/CompareTo.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/intrinsics/CompareTo.kt @@ -19,23 +19,17 @@ package org.jetbrains.kotlin.codegen.intrinsics import org.jetbrains.kotlin.codegen.AsmUtil.comparisonOperandType import org.jetbrains.kotlin.codegen.Callable import org.jetbrains.kotlin.codegen.CallableMethod -import org.jetbrains.kotlin.config.JvmTarget import org.jetbrains.org.objectweb.asm.Type import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter -class CompareTo(private val jvmTarget: JvmTarget) : IntrinsicMethod() { +class CompareTo : IntrinsicMethod() { private fun genInvoke(type: Type?, v: InstructionAdapter) { when (type) { Type.INT_TYPE, Type.CHAR_TYPE -> v.invokestatic(IntrinsicMethods.INTRINSICS_CLASS_NAME, "compare", "(II)I", false) Type.LONG_TYPE -> v.lcmp() Type.FLOAT_TYPE -> v.invokestatic("java/lang/Float", "compare", "(FF)I", false) Type.DOUBLE_TYPE -> v.invokestatic("java/lang/Double", "compare", "(DD)I", false) - Type.BOOLEAN_TYPE -> { - check(jvmTarget >= JvmTarget.JVM_1_8) { - "Cannot generate boolean comparison for JVM target 1.6" - } - v.invokestatic("java/lang/Boolean", "compare", "(ZZ)I", false) - } + Type.BOOLEAN_TYPE -> v.invokestatic("java/lang/Boolean", "compare", "(ZZ)I", false) else -> throw UnsupportedOperationException() } } diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/intrinsics/HashCode.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/intrinsics/HashCode.kt index 0247013eece..9e032c68ff8 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/intrinsics/HashCode.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/intrinsics/HashCode.kt @@ -19,16 +19,15 @@ package org.jetbrains.kotlin.codegen.intrinsics import org.jetbrains.kotlin.codegen.AsmUtil import org.jetbrains.kotlin.codegen.Callable import org.jetbrains.kotlin.codegen.CallableMethod -import org.jetbrains.kotlin.config.JvmTarget import org.jetbrains.kotlin.resolve.jvm.AsmTypes import org.jetbrains.org.objectweb.asm.Opcodes import org.jetbrains.org.objectweb.asm.Type import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter -class HashCode(private val jvmTarget: JvmTarget) : IntrinsicMethod() { +class HashCode : IntrinsicMethod() { override fun toCallable(method: CallableMethod): Callable { val receiverType = method.dispatchReceiverType ?: method.extensionReceiverType ?: error("No receiver for callable: $method") - val useObjectHashCode = JvmTarget.JVM_1_6 == jvmTarget || !AsmUtil.isPrimitive(receiverType) + val useObjectHashCode = !AsmUtil.isPrimitive(receiverType) return object : IntrinsicCallable( Type.INT_TYPE, emptyList(), diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/intrinsics/IntrinsicMethods.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/intrinsics/IntrinsicMethods.java index fa5a8101e82..805216c683e 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/intrinsics/IntrinsicMethods.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/intrinsics/IntrinsicMethods.java @@ -63,11 +63,11 @@ public class IntrinsicMethods { private static final IntrinsicMethod ARRAY_ITERATOR = new ArrayIterator(); private final IntrinsicsMap intrinsicsMap = new IntrinsicsMap(); - public IntrinsicMethods(JvmTarget jvmTarget) { - this(jvmTarget, false); + public IntrinsicMethods(@SuppressWarnings("unused") JvmTarget jvmTarget) { + this(false); } - public IntrinsicMethods(JvmTarget jvmTarget, boolean canReplaceStdlibRuntimeApiBehavior) { + public IntrinsicMethods(boolean canReplaceStdlibRuntimeApiBehavior) { intrinsicsMap.registerIntrinsic(KOTLIN_JVM, RECEIVER_PARAMETER_FQ_NAME, "javaClass", -1, JavaClassProperty.INSTANCE); intrinsicsMap.registerIntrinsic(KOTLIN_JVM, StandardNames.FqNames.kClass, "java", -1, new KClassJavaProperty()); intrinsicsMap.registerIntrinsic(KOTLIN_JVM, StandardNames.FqNames.kClass, "javaObjectType", -1, new KClassJavaObjectTypeProperty()); @@ -104,7 +104,7 @@ public class IntrinsicMethods { declareIntrinsicFunction(typeFqName, "dec", 0, DEC); } - IntrinsicMethod hashCode = new HashCode(jvmTarget); + IntrinsicMethod hashCode = new HashCode(); for (PrimitiveType type : PrimitiveType.values()) { FqName typeFqName = type.getTypeFqName(); Type wrapperType = AsmUtil.asmTypeByFqNameWithoutInnerClasses(JvmPrimitiveType.get(type).getWrapperFqName()); @@ -149,41 +149,39 @@ public class IntrinsicMethods { intrinsicsMap.registerIntrinsic(BUILT_INS_PACKAGE_FQ_NAME, null, "arrayOfNulls", 1, new NewArray()); for (PrimitiveType type : PrimitiveType.values()) { - declareIntrinsicFunction(type.getTypeFqName(), "compareTo", 1, new CompareTo(jvmTarget)); + declareIntrinsicFunction(type.getTypeFqName(), "compareTo", 1, new CompareTo()); declareIntrinsicFunction(COLLECTIONS_PACKAGE_FQ_NAME.child(Name.identifier(type.getTypeName().asString() + "Iterator")), "next", 0, ITERATOR_NEXT); } declareArrayMethods(); - if (jvmTarget.compareTo(JvmTarget.JVM_1_8) >= 0) { - Java8UIntDivide java8UIntDivide = new Java8UIntDivide(); - intrinsicsMap.registerIntrinsic(KOTLIN_UINT.toSafe(), null, "div", 1, java8UIntDivide); - intrinsicsMap.registerIntrinsic(BUILT_INS_PACKAGE_FQ_NAME, null, "uintDivide", 2, java8UIntDivide); + Java8UIntDivide java8UIntDivide = new Java8UIntDivide(); + intrinsicsMap.registerIntrinsic(KOTLIN_UINT.toSafe(), null, "div", 1, java8UIntDivide); + intrinsicsMap.registerIntrinsic(BUILT_INS_PACKAGE_FQ_NAME, null, "uintDivide", 2, java8UIntDivide); - Java8UIntRemainder java8UIntRemainder = new Java8UIntRemainder(); - intrinsicsMap.registerIntrinsic(KOTLIN_UINT.toSafe(), null, "rem", 1, java8UIntRemainder); - intrinsicsMap.registerIntrinsic(BUILT_INS_PACKAGE_FQ_NAME, null, "uintRemainder", 2, java8UIntRemainder); + Java8UIntRemainder java8UIntRemainder = new Java8UIntRemainder(); + intrinsicsMap.registerIntrinsic(KOTLIN_UINT.toSafe(), null, "rem", 1, java8UIntRemainder); + intrinsicsMap.registerIntrinsic(BUILT_INS_PACKAGE_FQ_NAME, null, "uintRemainder", 2, java8UIntRemainder); - Java8UIntCompare java8UIntCompare = new Java8UIntCompare(); - intrinsicsMap.registerIntrinsic(KOTLIN_UINT.toSafe(), null, "compareTo", 1, java8UIntCompare); - intrinsicsMap.registerIntrinsic(BUILT_INS_PACKAGE_FQ_NAME, null, "uintCompare", 2, java8UIntCompare); + Java8UIntCompare java8UIntCompare = new Java8UIntCompare(); + intrinsicsMap.registerIntrinsic(KOTLIN_UINT.toSafe(), null, "compareTo", 1, java8UIntCompare); + intrinsicsMap.registerIntrinsic(BUILT_INS_PACKAGE_FQ_NAME, null, "uintCompare", 2, java8UIntCompare); - intrinsicsMap.registerIntrinsic(KOTLIN_UINT.toSafe(), null, "toString", 0, new Java8UIntToString()); + intrinsicsMap.registerIntrinsic(KOTLIN_UINT.toSafe(), null, "toString", 0, new Java8UIntToString()); - Java8ULongDivide java8ULongDivide = new Java8ULongDivide(); - intrinsicsMap.registerIntrinsic(KOTLIN_ULONG.toSafe(), null, "div", 1, java8ULongDivide); - intrinsicsMap.registerIntrinsic(BUILT_INS_PACKAGE_FQ_NAME, null, "ulongDivide", 2, java8ULongDivide); + Java8ULongDivide java8ULongDivide = new Java8ULongDivide(); + intrinsicsMap.registerIntrinsic(KOTLIN_ULONG.toSafe(), null, "div", 1, java8ULongDivide); + intrinsicsMap.registerIntrinsic(BUILT_INS_PACKAGE_FQ_NAME, null, "ulongDivide", 2, java8ULongDivide); - Java8ULongRemainder java8ULongRemainder = new Java8ULongRemainder(); - intrinsicsMap.registerIntrinsic(KOTLIN_ULONG.toSafe(), null, "rem", 1, java8ULongRemainder); - intrinsicsMap.registerIntrinsic(BUILT_INS_PACKAGE_FQ_NAME, null, "ulongRemainder", 2, java8ULongRemainder); + Java8ULongRemainder java8ULongRemainder = new Java8ULongRemainder(); + intrinsicsMap.registerIntrinsic(KOTLIN_ULONG.toSafe(), null, "rem", 1, java8ULongRemainder); + intrinsicsMap.registerIntrinsic(BUILT_INS_PACKAGE_FQ_NAME, null, "ulongRemainder", 2, java8ULongRemainder); - Java8ULongCompare java8ULongCompare = new Java8ULongCompare(); - intrinsicsMap.registerIntrinsic(KOTLIN_ULONG.toSafe(), null, "compareTo", 1, java8ULongCompare); - intrinsicsMap.registerIntrinsic(BUILT_INS_PACKAGE_FQ_NAME, null, "ulongCompare", 2, java8ULongCompare); + Java8ULongCompare java8ULongCompare = new Java8ULongCompare(); + intrinsicsMap.registerIntrinsic(KOTLIN_ULONG.toSafe(), null, "compareTo", 1, java8ULongCompare); + intrinsicsMap.registerIntrinsic(BUILT_INS_PACKAGE_FQ_NAME, null, "ulongCompare", 2, java8ULongCompare); - intrinsicsMap.registerIntrinsic(KOTLIN_ULONG.toSafe(), null, "toString", 0, new Java8ULongToString()); - } + intrinsicsMap.registerIntrinsic(KOTLIN_ULONG.toSafe(), null, "toString", 0, new Java8ULongToString()); } private void declareArrayMethods() { diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/GenerationState.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/GenerationState.kt index ed8edde8dc0..bb364c59ae5 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/GenerationState.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/GenerationState.kt @@ -37,7 +37,10 @@ import org.jetbrains.kotlin.psi.KtClassOrObject import org.jetbrains.kotlin.psi.KtCodeFragment import org.jetbrains.kotlin.psi.KtFile import org.jetbrains.kotlin.psi.KtScript -import org.jetbrains.kotlin.resolve.* +import org.jetbrains.kotlin.resolve.BindingContext +import org.jetbrains.kotlin.resolve.BindingTrace +import org.jetbrains.kotlin.resolve.BindingTraceFilter +import org.jetbrains.kotlin.resolve.DelegatingBindingTrace import org.jetbrains.kotlin.resolve.deprecation.DeprecationResolver import org.jetbrains.kotlin.resolve.diagnostics.Diagnostics import org.jetbrains.kotlin.resolve.diagnostics.OnDemandSuppressCache @@ -241,26 +244,18 @@ class GenerationState private constructor( configuration.get(JVMConfigurationKeys.STRING_CONCAT) ?: JvmStringConcat.INDY_WITH_CONSTANTS else JvmStringConcat.INLINE - val samConversionsScheme = run { - val fromConfig = configuration.get(JVMConfigurationKeys.SAM_CONVERSIONS) - if (fromConfig != null && target >= fromConfig.minJvmTarget) - fromConfig - else if ( - target >= JvmClosureGenerationScheme.INDY.minJvmTarget && - languageVersionSettings.supportsFeature(LanguageFeature.SamWrapperClassesAreSynthetic) - ) - JvmClosureGenerationScheme.INDY - else - JvmClosureGenerationScheme.CLASS - } + val samConversionsScheme: JvmClosureGenerationScheme = + configuration.get(JVMConfigurationKeys.SAM_CONVERSIONS) + ?: if (languageVersionSettings.supportsFeature(LanguageFeature.SamWrapperClassesAreSynthetic)) + JvmClosureGenerationScheme.INDY + else + JvmClosureGenerationScheme.CLASS - val lambdasScheme = configuration.get(JVMConfigurationKeys.LAMBDAS).let { fromConfig -> - if (fromConfig == null || target < fromConfig.minJvmTarget) { - if (languageVersionSettings.supportsFeature(LanguageFeature.LightweightLambdas) && target >= JvmClosureGenerationScheme.INDY.minJvmTarget) + val lambdasScheme: JvmClosureGenerationScheme = + configuration.get(JVMConfigurationKeys.LAMBDAS) + ?: if (languageVersionSettings.supportsFeature(LanguageFeature.LightweightLambdas)) JvmClosureGenerationScheme.INDY else JvmClosureGenerationScheme.CLASS - } else fromConfig - } val moduleName: String = moduleName ?: JvmCodegenUtil.getModuleName(module) val classBuilderMode: ClassBuilderMode = builderFactory.classBuilderMode @@ -280,7 +275,7 @@ class GenerationState private constructor( isIrBackend ) val canReplaceStdlibRuntimeApiBehavior = languageVersionSettings.apiVersion <= ApiVersion.parse(KotlinVersion.CURRENT.toString())!! - val intrinsics: IntrinsicMethods = IntrinsicMethods(target, canReplaceStdlibRuntimeApiBehavior) + val intrinsics: IntrinsicMethods = IntrinsicMethods(canReplaceStdlibRuntimeApiBehavior) val generateOptimizedCallableReferenceSuperClasses = languageVersionSettings.apiVersion >= ApiVersion.KOTLIN_1_4 && !configuration.getBoolean(JVMConfigurationKeys.NO_OPTIMIZED_CALLABLE_REFERENCES) diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/KotlinTypeMapper.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/KotlinTypeMapper.kt index 9a6c6ebeb42..201b2713fb8 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/KotlinTypeMapper.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/KotlinTypeMapper.kt @@ -574,8 +574,7 @@ class KotlinTypeMapper @JvmOverloads constructor( mapDefaultCallback(baseMethodDescriptor, getKindForDefaultImplCall(baseMethodDescriptor)), signature, invokeOpcode, thisClass, dispatchReceiverKotlinType, receiverParameterType, extensionReceiverKotlinType, calleeType, returnKotlinType, - if (jvmTarget >= JvmTarget.JVM_1_8) isInterfaceMember else invokeOpcode == INVOKEINTERFACE, - isDefaultMethodInInterface, boxInlineClassBeforeInvoke + isInterfaceMember, isDefaultMethodInInterface, boxInlineClassBeforeInvoke ) } diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/jvmArguments.kt b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/jvmArguments.kt index 8147c172343..4cd2991c269 100644 --- a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/jvmArguments.kt +++ b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/jvmArguments.kt @@ -77,14 +77,6 @@ fun CompilerConfiguration.setupJvmSpecificArguments(arguments: K2JVMCompilerArgu val jvmDefaultMode = languageVersionSettings.getFlag(JvmAnalysisFlags.jvmDefaultMode) val jvmTarget = get(JVMConfigurationKeys.JVM_TARGET) ?: JvmTarget.DEFAULT - if (jvmTarget.majorVersion < JvmTarget.JVM_1_8.majorVersion) { - if (jvmDefaultMode.forAllMethodsWithBody) { - messageCollector.report( - ERROR, - "'-Xjvm-default=${jvmDefaultMode.description}' is only supported since JVM target 1.8. Recompile with '-jvm-target 1.8'" - ) - } - } if (jvmDefaultMode == JvmDefaultMode.ENABLE || jvmDefaultMode == JvmDefaultMode.ENABLE_WITH_DEFAULT_IMPLS) { messageCollector.report( @@ -112,8 +104,8 @@ fun CompilerConfiguration.setupJvmSpecificArguments(arguments: K2JVMCompilerArgu } } - handleClosureGenerationSchemeArgument("-Xsam-conversions", arguments.samConversions, JVMConfigurationKeys.SAM_CONVERSIONS, jvmTarget) - handleClosureGenerationSchemeArgument("-Xlambdas", arguments.lambdas, JVMConfigurationKeys.LAMBDAS, jvmTarget) + handleClosureGenerationSchemeArgument("-Xsam-conversions", arguments.samConversions, JVMConfigurationKeys.SAM_CONVERSIONS) + handleClosureGenerationSchemeArgument("-Xlambdas", arguments.lambdas, JVMConfigurationKeys.LAMBDAS) addAll(JVMConfigurationKeys.ADDITIONAL_JAVA_MODULES, arguments.additionalJavaModules?.asList()) } @@ -122,26 +114,18 @@ private fun CompilerConfiguration.handleClosureGenerationSchemeArgument( flag: String, value: String?, key: CompilerConfigurationKey, - jvmTarget: JvmTarget ) { - if (value != null) { - val parsedValue = JvmClosureGenerationScheme.fromString(value) - if (parsedValue != null) { - put(key, parsedValue) - if (jvmTarget < parsedValue.minJvmTarget) { - messageCollector.report( - WARNING, - "`$flag=$value` requires JVM target at least " + - "${parsedValue.minJvmTarget.description} and is ignored." - ) - } - } else { - messageCollector.report( - ERROR, - "Unknown `$flag` argument: ${value}\n." + - "Supported arguments: ${JvmClosureGenerationScheme.values().joinToString { it.description }}" - ) - } + if (value == null) return + + val parsedValue = JvmClosureGenerationScheme.fromString(value) + if (parsedValue != null) { + put(key, parsedValue) + } else { + messageCollector.report( + ERROR, + "Unknown `$flag` argument: ${value}\n." + + "Supported arguments: ${JvmClosureGenerationScheme.values().joinToString { it.description }}" + ) } } diff --git a/compiler/config.jvm/src/org/jetbrains/kotlin/config/JvmClosureGenerationScheme.kt b/compiler/config.jvm/src/org/jetbrains/kotlin/config/JvmClosureGenerationScheme.kt index d8995c54fff..b01553a651f 100644 --- a/compiler/config.jvm/src/org/jetbrains/kotlin/config/JvmClosureGenerationScheme.kt +++ b/compiler/config.jvm/src/org/jetbrains/kotlin/config/JvmClosureGenerationScheme.kt @@ -7,12 +7,9 @@ package org.jetbrains.kotlin.config import org.jetbrains.kotlin.util.capitalizeDecapitalize.toLowerCaseAsciiOnly -enum class JvmClosureGenerationScheme( - val description: String, - val minJvmTarget: JvmTarget -) { - CLASS("class", JvmTarget.JVM_1_6), - INDY("indy", JvmTarget.JVM_1_8), +enum class JvmClosureGenerationScheme(val description: String) { + CLASS("class"), + INDY("indy"), ; companion object { @@ -22,4 +19,4 @@ enum class JvmClosureGenerationScheme( return values().find { it.description == lowerStr } } } -} \ No newline at end of file +} diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/AnnotationCodegen.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/AnnotationCodegen.kt index 382fb44a840..88624a1dbdb 100644 --- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/AnnotationCodegen.kt +++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/AnnotationCodegen.kt @@ -28,7 +28,6 @@ import org.jetbrains.kotlin.codegen.AsmUtil import org.jetbrains.kotlin.codegen.TypeAnnotationCollector import org.jetbrains.kotlin.codegen.TypePathInfo import org.jetbrains.kotlin.config.JVMConfigurationKeys -import org.jetbrains.kotlin.config.JvmTarget.JVM_1_6 import org.jetbrains.kotlin.descriptors.DescriptorVisibilities import org.jetbrains.kotlin.descriptors.annotations.KotlinRetention import org.jetbrains.kotlin.descriptors.annotations.KotlinTarget @@ -292,50 +291,48 @@ abstract class AnnotationCodegen( boundType: Int, visitor: (typeRef: Int, typePath: TypePath?, descriptor: String, visible: Boolean) -> AnnotationVisitor ) { - if (context.state.target != JVM_1_6) { - typeParameterContainer.typeParameters.forEachIndexed { index, typeParameter -> - object : AnnotationCodegen(classCodegen, true) { - override fun visitAnnotation(descr: String, visible: Boolean): AnnotationVisitor { + typeParameterContainer.typeParameters.forEachIndexed { index, typeParameter -> + object : AnnotationCodegen(classCodegen, true) { + override fun visitAnnotation(descr: String, visible: Boolean): AnnotationVisitor { - return visitor( - TypeReference.newTypeParameterReference(referenceType, index).value, - null, - descr, - visible - ) - } + return visitor( + TypeReference.newTypeParameterReference(referenceType, index).value, + null, + descr, + visible + ) + } - override fun visitTypeAnnotation(descr: String, path: TypePath?, visible: Boolean): AnnotationVisitor { - throw RuntimeException( - "Error during generation: type annotation shouldn't be presented on type parameter: " + - "${ir2string(typeParameter)} in ${ir2string(typeParameterContainer)}" - ) - } - }.genAnnotations(typeParameter, null, null) + override fun visitTypeAnnotation(descr: String, path: TypePath?, visible: Boolean): AnnotationVisitor { + throw RuntimeException( + "Error during generation: type annotation shouldn't be presented on type parameter: " + + "${ir2string(typeParameter)} in ${ir2string(typeParameterContainer)}" + ) + } + }.genAnnotations(typeParameter, null, null) - if (context.state.configuration.getBoolean(JVMConfigurationKeys.EMIT_JVM_TYPE_ANNOTATIONS)) { - var superInterfaceIndex = 1 - typeParameter.superTypes.forEach { superType -> - val isClassOrTypeParameter = !superType.isInterface() && !superType.isAnnotation() - val superIndex = if (isClassOrTypeParameter) 0 else superInterfaceIndex++ - object : AnnotationCodegen(classCodegen, true) { - override fun visitAnnotation(descr: String, visible: Boolean): AnnotationVisitor { - throw RuntimeException( - "Error during generation: only type annotations should be presented on type parameters bounds: " + - "${ir2string(typeParameter)} in ${ir2string(typeParameter)}" - ) - } + if (context.state.configuration.getBoolean(JVMConfigurationKeys.EMIT_JVM_TYPE_ANNOTATIONS)) { + var superInterfaceIndex = 1 + typeParameter.superTypes.forEach { superType -> + val isClassOrTypeParameter = !superType.isInterface() && !superType.isAnnotation() + val superIndex = if (isClassOrTypeParameter) 0 else superInterfaceIndex++ + object : AnnotationCodegen(classCodegen, true) { + override fun visitAnnotation(descr: String, visible: Boolean): AnnotationVisitor { + throw RuntimeException( + "Error during generation: only type annotations should be presented on type parameters bounds: " + + "${ir2string(typeParameter)} in ${ir2string(typeParameter)}" + ) + } - override fun visitTypeAnnotation(descr: String, path: TypePath?, visible: Boolean): AnnotationVisitor { - return visitor( - TypeReference.newTypeParameterBoundReference(boundType, index, superIndex).value, - path, - descr, - visible - ) - } - }.generateTypeAnnotations(typeParameterContainer, superType) - } + override fun visitTypeAnnotation(descr: String, path: TypePath?, visible: Boolean): AnnotationVisitor { + return visitor( + TypeReference.newTypeParameterBoundReference(boundType, index, superIndex).value, + path, + descr, + visible + ) + } + }.generateTypeAnnotations(typeParameterContainer, superType) } } } @@ -401,8 +398,7 @@ abstract class AnnotationCodegen( type: IrType? ) { if ((annotated as? IrDeclaration)?.origin == JvmLoweredDeclarationOrigin.SYNTHETIC_ACCESSOR || - type == null || context.state.target === JVM_1_6 || - !context.state.configuration.getBoolean(JVMConfigurationKeys.EMIT_JVM_TYPE_ANNOTATIONS) + type == null || !context.state.configuration.getBoolean(JVMConfigurationKeys.EMIT_JVM_TYPE_ANNOTATIONS) ) { return } diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/CompareTo.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/CompareTo.kt index 3910d8e2263..771cee69313 100644 --- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/CompareTo.kt +++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/CompareTo.kt @@ -27,7 +27,6 @@ import org.jetbrains.kotlin.codegen.AsmUtil.comparisonOperandType import org.jetbrains.kotlin.codegen.BranchedValue import org.jetbrains.kotlin.codegen.NumberCompare import org.jetbrains.kotlin.codegen.ObjectCompare -import org.jetbrains.kotlin.config.JvmTarget import org.jetbrains.kotlin.config.LanguageFeature import org.jetbrains.kotlin.ir.expressions.IrFunctionAccessExpression import org.jetbrains.kotlin.lexer.KtSingleValueToken @@ -39,21 +38,14 @@ import org.jetbrains.org.objectweb.asm.Type import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter object CompareTo : IntrinsicMethod() { - private fun genInvoke(type: Type?, v: InstructionAdapter, classCodegen: ClassCodegen) { + private fun genInvoke(type: Type?, v: InstructionAdapter) { when (type) { Type.CHAR_TYPE, Type.BYTE_TYPE, Type.SHORT_TYPE, Type.INT_TYPE -> v.invokestatic(JvmSymbols.INTRINSICS_CLASS_NAME, "compare", "(II)I", false) Type.LONG_TYPE -> v.invokestatic(JvmSymbols.INTRINSICS_CLASS_NAME, "compare", "(JJ)I", false) Type.FLOAT_TYPE -> v.invokestatic("java/lang/Float", "compare", "(FF)I", false) Type.DOUBLE_TYPE -> v.invokestatic("java/lang/Double", "compare", "(DD)I", false) - Type.BOOLEAN_TYPE -> { - // We could support it for JVM target 1.6, but it's prohibited now anyway (except for stdlib, which doesn't have such code), - // so throwing an exception instead. - check(classCodegen.context.state.target >= JvmTarget.JVM_1_8) { - "Cannot generate boolean comparison for JVM target 1.6" - } - v.invokestatic("java/lang/Boolean", "compare", "(ZZ)I", false) - } + Type.BOOLEAN_TYPE -> v.invokestatic("java/lang/Boolean", "compare", "(ZZ)I", false) else -> throw UnsupportedOperationException() } } @@ -70,7 +62,7 @@ object CompareTo : IntrinsicMethod() { signature.valueParameters.single().asmType, ) return IrIntrinsicFunction.create(expression, signature, classCodegen, listOf(parameterType, parameterType)) { - genInvoke(parameterType, it, classCodegen) + genInvoke(parameterType, it) } } } diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/HashCode.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/HashCode.kt index 1333b221491..6f0233017ba 100644 --- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/HashCode.kt +++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/HashCode.kt @@ -20,7 +20,6 @@ import org.jetbrains.kotlin.backend.jvm.JvmLoweredDeclarationOrigin import org.jetbrains.kotlin.backend.jvm.codegen.* import org.jetbrains.kotlin.codegen.AsmUtil import org.jetbrains.kotlin.codegen.DescriptorAsmUtil -import org.jetbrains.kotlin.config.JvmTarget import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin import org.jetbrains.kotlin.ir.expressions.IrFunctionAccessExpression import org.jetbrains.kotlin.ir.util.render @@ -43,7 +42,7 @@ object HashCode : IntrinsicMethod() { // TODO generate or lower IR for data class / value class 'hashCode'? DescriptorAsmUtil.genHashCode(mv, mv, receiverType, target) } - target >= JvmTarget.JVM_1_8 && AsmUtil.isPrimitive(receiverJvmType) -> { + AsmUtil.isPrimitive(receiverJvmType) -> { val boxedType = AsmUtil.boxPrimitiveType(receiverJvmType) ?: throw AssertionError("Primitive type expected: $receiverJvmType") receiverValue.materializeAt(receiverJvmType, receiverIrType) diff --git a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmBuiltInsLowering.kt b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmBuiltInsLowering.kt index f8eb2a6acae..bced25a83d6 100644 --- a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmBuiltInsLowering.kt +++ b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmBuiltInsLowering.kt @@ -11,7 +11,6 @@ import org.jetbrains.kotlin.backend.common.phaser.makeIrFilePhase import org.jetbrains.kotlin.backend.jvm.JvmBackendContext import org.jetbrains.kotlin.backend.jvm.ir.createJvmIrBuilder import org.jetbrains.kotlin.backend.jvm.ir.irArrayOf -import org.jetbrains.kotlin.config.JvmTarget import org.jetbrains.kotlin.ir.declarations.IrFile import org.jetbrains.kotlin.ir.expressions.IrCall import org.jetbrains.kotlin.ir.expressions.IrExpression @@ -36,22 +35,19 @@ class JvmBuiltInsLowering(val context: JvmBackendContext) : FileLoweringPass { expression.transformChildren(this, null) val callee = expression.symbol.owner - - if (context.state.target >= JvmTarget.JVM_1_8) { - val parentClassName = callee.parent.fqNameForIrSerialization.asString() - val functionName = callee.name.asString() - if (parentClassName == "kotlin.CompareToKt" && functionName == "compareTo") { - val operandType = expression.getValueArgument(0)!!.type - when { - operandType.isUInt() -> return expression.replaceWithCallTo(context.ir.symbols.compareUnsignedInt) - operandType.isULong() -> return expression.replaceWithCallTo(context.ir.symbols.compareUnsignedLong) - } - } - val jvm8Replacement = jvm8builtInReplacements[parentClassName to functionName] - if (jvm8Replacement != null) { - return expression.replaceWithCallTo(jvm8Replacement) + val parentClassName = callee.parent.fqNameForIrSerialization.asString() + val functionName = callee.name.asString() + if (parentClassName == "kotlin.CompareToKt" && functionName == "compareTo") { + val operandType = expression.getValueArgument(0)!!.type + when { + operandType.isUInt() -> return expression.replaceWithCallTo(context.ir.symbols.compareUnsignedInt) + operandType.isULong() -> return expression.replaceWithCallTo(context.ir.symbols.compareUnsignedLong) } } + val jvm8Replacement = jvm8builtInReplacements[parentClassName to functionName] + if (jvm8Replacement != null) { + return expression.replaceWithCallTo(jvm8Replacement) + } return when { callee.isArrayOf() -> diff --git a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/elements/KtLightModifierListDescriptorBased.kt b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/elements/KtLightModifierListDescriptorBased.kt index ea15fa94358..6c1f5159c6a 100644 --- a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/elements/KtLightModifierListDescriptorBased.kt +++ b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/elements/KtLightModifierListDescriptorBased.kt @@ -89,7 +89,7 @@ abstract class KtUltraLightModifierList sourceAnnotation.additionalConverter() - ?: sourceAnnotation.tryConvertAsTarget(support) + ?: sourceAnnotation.tryConvertAsTarget() ?: sourceAnnotation.tryConvertAsRetention() ?: sourceAnnotation.tryConvertAsRepeatable(owner) ?: sourceAnnotation.tryConvertAsMustBeDocumented() diff --git a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/elements/KtToJvmAnnotationsConverter.kt b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/elements/KtToJvmAnnotationsConverter.kt index c29b7f41c65..51f67efb337 100644 --- a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/elements/KtToJvmAnnotationsConverter.kt +++ b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/elements/KtToJvmAnnotationsConverter.kt @@ -8,9 +8,7 @@ package org.jetbrains.kotlin.asJava.elements import com.intellij.psi.* import com.intellij.psi.CommonClassNames.* import org.jetbrains.kotlin.asJava.classes.KtUltraLightSimpleAnnotation -import org.jetbrains.kotlin.asJava.classes.KtUltraLightSupport import org.jetbrains.kotlin.builtins.StandardNames.FqNames -import org.jetbrains.kotlin.config.JvmTarget import org.jetbrains.kotlin.load.java.JvmAbi import org.jetbrains.kotlin.load.java.JvmAnnotationNames import org.jetbrains.kotlin.name.ClassId @@ -24,7 +22,6 @@ import org.jetbrains.kotlin.resolve.constants.ConstantValue import org.jetbrains.kotlin.resolve.constants.EnumValue import org.jetbrains.kotlin.resolve.constants.KClassValue import org.jetbrains.kotlin.utils.addToStdlib.safeAs -import java.util.* internal const val KOTLIN_JVM_INTERNAL_REPEATABLE_CONTAINER = "kotlin.jvm.internal.RepeatableContainer" @@ -56,9 +53,9 @@ private fun PsiAnnotation.extractArrayAnnotationFqNames(attributeName: String): .map { "${it.first.asSingleFqName().asString()}.${it.second.identifier}" } } -private val targetMappings = EnumMap>(JvmTarget::class.java).also { result -> +private val targetMapping = run { val javaAnnotationElementTypeId = ClassId.fromString(JvmAnnotationNames.ELEMENT_TYPE_ENUM.asString()) - val jdk6 = hashMapOf( + hashMapOf( "kotlin.annotation.AnnotationTarget.CLASS" to EnumValue(javaAnnotationElementTypeId, Name.identifier("TYPE")), "kotlin.annotation.AnnotationTarget.ANNOTATION_CLASS" to EnumValue(javaAnnotationElementTypeId, Name.identifier("ANNOTATION_TYPE")), "kotlin.annotation.AnnotationTarget.FIELD" to EnumValue(javaAnnotationElementTypeId, Name.identifier("FIELD")), @@ -67,18 +64,13 @@ private val targetMappings = EnumMap>(JvmTarge "kotlin.annotation.AnnotationTarget.CONSTRUCTOR" to EnumValue(javaAnnotationElementTypeId, Name.identifier("CONSTRUCTOR")), "kotlin.annotation.AnnotationTarget.FUNCTION" to EnumValue(javaAnnotationElementTypeId, Name.identifier("METHOD")), "kotlin.annotation.AnnotationTarget.PROPERTY_GETTER" to EnumValue(javaAnnotationElementTypeId, Name.identifier("METHOD")), - "kotlin.annotation.AnnotationTarget.PROPERTY_SETTER" to EnumValue(javaAnnotationElementTypeId, Name.identifier("METHOD")) + "kotlin.annotation.AnnotationTarget.PROPERTY_SETTER" to EnumValue(javaAnnotationElementTypeId, Name.identifier("METHOD")), + "kotlin.annotation.AnnotationTarget.TYPE_PARAMETER" to EnumValue(javaAnnotationElementTypeId, Name.identifier("TYPE_PARAMETER")), + "kotlin.annotation.AnnotationTarget.TYPE" to EnumValue(javaAnnotationElementTypeId, Name.identifier("TYPE_USE")), ) - val jdk8AndLater = HashMap(jdk6).apply { - put("kotlin.annotation.AnnotationTarget.TYPE_PARAMETER", EnumValue(javaAnnotationElementTypeId, Name.identifier("TYPE_PARAMETER"))) - put("kotlin.annotation.AnnotationTarget.TYPE", EnumValue(javaAnnotationElementTypeId, Name.identifier("TYPE_USE"))) - } - for (target in JvmTarget.values()) { - result[target] = if (target >= JvmTarget.JVM_1_8) jdk8AndLater else jdk6 - } } -internal fun PsiAnnotation.tryConvertAsTarget(support: KtUltraLightSupport): KtLightAbstractAnnotation? { +internal fun PsiAnnotation.tryConvertAsTarget(): KtLightAbstractAnnotation? { if (FqNames.target.asString() != qualifiedName) return null @@ -87,7 +79,6 @@ internal fun PsiAnnotation.tryConvertAsTarget(support: KtUltraLightSupport): KtL attributeValues ?: return null - val targetMapping = targetMappings.getValue(support.jvmTarget) val convertedValues = attributeValues.mapNotNull { targetMapping[it] }.distinct() val targetAttributes = "value" to ArrayValue(convertedValues) { module -> module.builtIns.array.defaultType } diff --git a/compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/test/util/KtTestUtil.java b/compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/test/util/KtTestUtil.java index 91a1fcfcac2..2d0d1a2daf9 100644 --- a/compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/test/util/KtTestUtil.java +++ b/compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/test/util/KtTestUtil.java @@ -144,11 +144,6 @@ public class KtTestUtil { return System.getenv(propertyName); } - @NotNull - public static File getJdk6Home() { - return getJdkHome("JDK_1_6", "JDK_6", "JDK_16"); - } - @NotNull public static File getJdk8Home() { return getJdkHome("JDK_1_8", "JDK_8", "JDK_18"); diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/classic/JavaCompilerFacade.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/classic/JavaCompilerFacade.kt index d7ff2ecbb33..4c5d0454814 100644 --- a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/classic/JavaCompilerFacade.kt +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/classic/JavaCompilerFacade.kt @@ -65,8 +65,7 @@ class JavaCompilerFacade(private val testServices: TestServices) { } private fun compileJavaFiles(module: TestModule, jvmTarget: JvmTarget, files: List, javacOptions: List, ignoreErrors: Boolean) { - val targetIsJava8OrLower = System.getProperty("java.version").startsWith("1.") && jvmTarget <= JvmTarget.JVM_1_6 - if (USE_JAVAC_BASED_ON_JVM_TARGET !in module.directives || targetIsJava8OrLower) { + if (USE_JAVAC_BASED_ON_JVM_TARGET !in module.directives) { org.jetbrains.kotlin.test.compileJavaFiles( files, javacOptions, @@ -76,7 +75,6 @@ class JavaCompilerFacade(private val testServices: TestServices) { return } val jdkHome = when (jvmTarget) { - JvmTarget.JVM_1_6 -> KtTestUtil.getJdk6Home() JvmTarget.JVM_1_8 -> KtTestUtil.getJdk8Home() JvmTarget.JVM_9, JvmTarget.JVM_11 -> KtTestUtil.getJdk11Home() diff --git a/compiler/tests-compiler-utils/tests/org/jetbrains/kotlin/codegen/CodegenTestUtil.java b/compiler/tests-compiler-utils/tests/org/jetbrains/kotlin/codegen/CodegenTestUtil.java index d5a39012f2f..3665b90020e 100644 --- a/compiler/tests-compiler-utils/tests/org/jetbrains/kotlin/codegen/CodegenTestUtil.java +++ b/compiler/tests-compiler-utils/tests/org/jetbrains/kotlin/codegen/CodegenTestUtil.java @@ -188,7 +188,7 @@ public class CodegenTestUtil { public static String computeJavaTarget(@NotNull List javacOptions, @Nullable JvmTarget kotlinTarget) { if (JAVA_COMPILATION_TARGET != null && !javacOptions.contains("-target")) return JAVA_COMPILATION_TARGET; - if (kotlinTarget != null && kotlinTarget.compareTo(JvmTarget.JVM_1_6) > 0) + if (kotlinTarget != null) return kotlinTarget.getDescription(); if (IS_SOURCE_6_STILL_SUPPORTED) return "1.6"; diff --git a/compiler/tests-java8/tests/org/jetbrains/kotlin/jvm/repl/ReplCompilerJava8Test.kt b/compiler/tests-java8/tests/org/jetbrains/kotlin/jvm/repl/ReplCompilerJava8Test.kt index 95cb29ab5d3..56075a9a2c0 100644 --- a/compiler/tests-java8/tests/org/jetbrains/kotlin/jvm/repl/ReplCompilerJava8Test.kt +++ b/compiler/tests-java8/tests/org/jetbrains/kotlin/jvm/repl/ReplCompilerJava8Test.kt @@ -56,7 +56,6 @@ class ReplCompilerJava8Test : KtUsefulTestCase() { put(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY, PrintingMessageCollector(System.out, MessageRenderer.WITHOUT_PATHS, false)) addKotlinSourceRoot(tmpdir.absolutePath) put(JVMConfigurationKeys.OUTPUT_DIRECTORY, tmpdir) - put(JVMConfigurationKeys.JVM_TARGET, JvmTarget.JVM_1_8) loadScriptingPlugin(this) } diff --git a/compiler/tests/org/jetbrains/kotlin/serialization/JvmVersionRequirementTest.kt b/compiler/tests/org/jetbrains/kotlin/serialization/JvmVersionRequirementTest.kt index e0eda0de261..9b59db8970d 100644 --- a/compiler/tests/org/jetbrains/kotlin/serialization/JvmVersionRequirementTest.kt +++ b/compiler/tests/org/jetbrains/kotlin/serialization/JvmVersionRequirementTest.kt @@ -43,7 +43,6 @@ class JvmVersionRequirementTest : AbstractVersionRequirementTest() { KotlinCoreEnvironment.createForTests( testRootDisposable, KotlinTestUtils.newConfiguration(ConfigurationKind.ALL, TestJdkKind.MOCK_JDK, outputDirectory).apply { - put(JVMConfigurationKeys.JVM_TARGET, JvmTarget.JVM_1_8) languageVersionSettings = LanguageVersionSettingsImpl( languageVersion, ApiVersion.createByLanguageVersion(languageVersion),