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

JVM: remove most usages of JvmTarget.JVM_1_6

Browse Source
This commit is contained in:
Alexander Udalov
2023-05-12 10:50:07 +02:00
committed by Space Team
parent 75197d1b86
commit fb900d2e2a
20 changed files with 137 additions and 246 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/backend/src/org/jetbrains/kotlin/codegen/AnnotationCodegen.java
+12 -27
View File
@@ -22,7 +22,6 @@ import org.jetbrains.annotations.Nullable;
import org.jetbrains.kotlin.codegen.state.GenerationState; import org.jetbrains.kotlin.codegen.state.GenerationState;
import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper; import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper;
import org.jetbrains.kotlin.config.JVMConfigurationKeys; import org.jetbrains.kotlin.config.JVMConfigurationKeys;
import org.jetbrains.kotlin.config.JvmTarget;
import org.jetbrains.kotlin.descriptors.*; import org.jetbrains.kotlin.descriptors.*;
import org.jetbrains.kotlin.descriptors.annotations.*; import org.jetbrains.kotlin.descriptors.annotations.*;
import org.jetbrains.kotlin.descriptors.impl.AnonymousFunctionDescriptor; import org.jetbrains.kotlin.descriptors.impl.AnonymousFunctionDescriptor;
@@ -262,30 +261,20 @@ public abstract class AnnotationCodegen {
); );
} }
private static final Map<JvmTarget, Map<KotlinTarget, ElementType>> annotationTargetMaps = new EnumMap<>(JvmTarget.class); private static final Map<KotlinTarget, ElementType> annotationTargetMap = new EnumMap<>(KotlinTarget.class);
static { static {
Map<KotlinTarget, ElementType> jvm6 = new EnumMap<>(KotlinTarget.class); annotationTargetMap.put(KotlinTarget.CLASS, ElementType.TYPE);
jvm6.put(KotlinTarget.CLASS, ElementType.TYPE); annotationTargetMap.put(KotlinTarget.ANNOTATION_CLASS, ElementType.ANNOTATION_TYPE);
jvm6.put(KotlinTarget.ANNOTATION_CLASS, ElementType.ANNOTATION_TYPE); annotationTargetMap.put(KotlinTarget.CONSTRUCTOR, ElementType.CONSTRUCTOR);
jvm6.put(KotlinTarget.CONSTRUCTOR, ElementType.CONSTRUCTOR); annotationTargetMap.put(KotlinTarget.LOCAL_VARIABLE, ElementType.LOCAL_VARIABLE);
jvm6.put(KotlinTarget.LOCAL_VARIABLE, ElementType.LOCAL_VARIABLE); annotationTargetMap.put(KotlinTarget.FUNCTION, ElementType.METHOD);
jvm6.put(KotlinTarget.FUNCTION, ElementType.METHOD); annotationTargetMap.put(KotlinTarget.PROPERTY_GETTER, ElementType.METHOD);
jvm6.put(KotlinTarget.PROPERTY_GETTER, ElementType.METHOD); annotationTargetMap.put(KotlinTarget.PROPERTY_SETTER, ElementType.METHOD);
jvm6.put(KotlinTarget.PROPERTY_SETTER, ElementType.METHOD); annotationTargetMap.put(KotlinTarget.FIELD, ElementType.FIELD);
jvm6.put(KotlinTarget.FIELD, ElementType.FIELD); annotationTargetMap.put(KotlinTarget.VALUE_PARAMETER, ElementType.PARAMETER);
jvm6.put(KotlinTarget.VALUE_PARAMETER, ElementType.PARAMETER); annotationTargetMap.put(KotlinTarget.TYPE_PARAMETER, ElementType.TYPE_PARAMETER);
annotationTargetMap.put(KotlinTarget.TYPE, ElementType.TYPE_USE);
Map<KotlinTarget, ElementType> 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);
}
}
} }
private void generateTargetAnnotation( private void generateTargetAnnotation(
@@ -294,9 +283,6 @@ public abstract class AnnotationCodegen {
String descriptor = Type.getType(Target.class).getDescriptor(); String descriptor = Type.getType(Target.class).getDescriptor();
if (!annotationDescriptorsAlreadyPresent.add(descriptor)) return; if (!annotationDescriptorsAlreadyPresent.add(descriptor)) return;
Map<KotlinTarget, ElementType> annotationTargetMap = annotationTargetMaps.get(typeMapper.getJvmTarget());
if (annotationTargetMap == null) throw new AssertionError("No annotation target map for JVM target " + typeMapper.getJvmTarget());
Set<KotlinTarget> targets = AnnotationChecker.Companion.applicableTargetSetFromTargetAnnotationOrNull(classDescriptor); Set<KotlinTarget> targets = AnnotationChecker.Companion.applicableTargetSetFromTargetAnnotationOrNull(classDescriptor);
Set<ElementType> javaTargets; Set<ElementType> javaTargets;
if (targets == null) { if (targets == null) {
@@ -730,7 +716,6 @@ public abstract class AnnotationCodegen {
private void generateTypeAnnotations(@NotNull Annotated annotated, @Nullable KotlinType type) { private void generateTypeAnnotations(@NotNull Annotated annotated, @Nullable KotlinType type) {
if (isAccessor(annotated) || if (isAccessor(annotated) ||
type == null || type == null ||
state.getTarget() == JvmTarget.JVM_1_6 ||
!state.getConfiguration().getBoolean(JVMConfigurationKeys.EMIT_JVM_TYPE_ANNOTATIONS)) { !state.getConfiguration().getBoolean(JVMConfigurationKeys.EMIT_JVM_TYPE_ANNOTATIONS)) {
return; return;
} }
compiler/backend/src/org/jetbrains/kotlin/codegen/DescriptorAsmUtil.java
+1 -26
View File
@@ -52,7 +52,6 @@ import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.List; 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.AsmUtil.*;
import static org.jetbrains.kotlin.codegen.CodegenUtilKt.isToArrayFromCollection; import static org.jetbrains.kotlin.codegen.CodegenUtilKt.isToArrayFromCollection;
import static org.jetbrains.kotlin.codegen.JvmCodegenUtil.isConstOrHasJvmFieldAnnotation; import static org.jetbrains.kotlin.codegen.JvmCodegenUtil.isConstOrHasJvmFieldAnnotation;
@@ -598,34 +597,10 @@ public class DescriptorAsmUtil {
iv.mark(end); iv.mark(end);
} }
else { else {
if (JvmTarget.JVM_1_6 == jvmTarget) { HashCode.Companion.invokeHashCode(iv, type);
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);
}
} }
} }
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 @NotNull
public static StackValue genEqualsForExpressionsOnStack( public static StackValue genEqualsForExpressionsOnStack(
@NotNull IElementType opToken, @NotNull IElementType opToken,
compiler/backend/src/org/jetbrains/kotlin/codegen/intrinsics/CompareTo.kt
+2 -8
View File
@@ -19,23 +19,17 @@ package org.jetbrains.kotlin.codegen.intrinsics
import org.jetbrains.kotlin.codegen.AsmUtil.comparisonOperandType import org.jetbrains.kotlin.codegen.AsmUtil.comparisonOperandType
import org.jetbrains.kotlin.codegen.Callable import org.jetbrains.kotlin.codegen.Callable
import org.jetbrains.kotlin.codegen.CallableMethod 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.Type
import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter 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) { private fun genInvoke(type: Type?, v: InstructionAdapter) {
when (type) { when (type) {
Type.INT_TYPE, Type.CHAR_TYPE -> v.invokestatic(IntrinsicMethods.INTRINSICS_CLASS_NAME, "compare", "(II)I", false) Type.INT_TYPE, Type.CHAR_TYPE -> v.invokestatic(IntrinsicMethods.INTRINSICS_CLASS_NAME, "compare", "(II)I", false)
Type.LONG_TYPE -> v.lcmp() Type.LONG_TYPE -> v.lcmp()
Type.FLOAT_TYPE -> v.invokestatic("java/lang/Float", "compare", "(FF)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.DOUBLE_TYPE -> v.invokestatic("java/lang/Double", "compare", "(DD)I", false)
Type.BOOLEAN_TYPE -> { Type.BOOLEAN_TYPE -> v.invokestatic("java/lang/Boolean", "compare", "(ZZ)I", false)
check(jvmTarget >= JvmTarget.JVM_1_8) {
"Cannot generate boolean comparison for JVM target 1.6"
}
v.invokestatic("java/lang/Boolean", "compare", "(ZZ)I", false)
}
else -> throw UnsupportedOperationException() else -> throw UnsupportedOperationException()
} }
} }
compiler/backend/src/org/jetbrains/kotlin/codegen/intrinsics/HashCode.kt
+2 -3
View File
@@ -19,16 +19,15 @@ package org.jetbrains.kotlin.codegen.intrinsics
import org.jetbrains.kotlin.codegen.AsmUtil import org.jetbrains.kotlin.codegen.AsmUtil
import org.jetbrains.kotlin.codegen.Callable import org.jetbrains.kotlin.codegen.Callable
import org.jetbrains.kotlin.codegen.CallableMethod import org.jetbrains.kotlin.codegen.CallableMethod
import org.jetbrains.kotlin.config.JvmTarget
import org.jetbrains.kotlin.resolve.jvm.AsmTypes import org.jetbrains.kotlin.resolve.jvm.AsmTypes
import org.jetbrains.org.objectweb.asm.Opcodes import org.jetbrains.org.objectweb.asm.Opcodes
import org.jetbrains.org.objectweb.asm.Type import org.jetbrains.org.objectweb.asm.Type
import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter
class HashCode(private val jvmTarget: JvmTarget) : IntrinsicMethod() { class HashCode : IntrinsicMethod() {
override fun toCallable(method: CallableMethod): Callable { override fun toCallable(method: CallableMethod): Callable {
val receiverType = method.dispatchReceiverType ?: method.extensionReceiverType ?: error("No receiver for callable: $method") 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( return object : IntrinsicCallable(
Type.INT_TYPE, Type.INT_TYPE,
emptyList(), emptyList(),
compiler/backend/src/org/jetbrains/kotlin/codegen/intrinsics/IntrinsicMethods.java
+25 -27
View File
@@ -63,11 +63,11 @@ public class IntrinsicMethods {
private static final IntrinsicMethod ARRAY_ITERATOR = new ArrayIterator(); private static final IntrinsicMethod ARRAY_ITERATOR = new ArrayIterator();
private final IntrinsicsMap intrinsicsMap = new IntrinsicsMap(); private final IntrinsicsMap intrinsicsMap = new IntrinsicsMap();
public IntrinsicMethods(JvmTarget jvmTarget) { public IntrinsicMethods(@SuppressWarnings("unused") JvmTarget jvmTarget) {
this(jvmTarget, false); 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, 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, "java", -1, new KClassJavaProperty());
intrinsicsMap.registerIntrinsic(KOTLIN_JVM, StandardNames.FqNames.kClass, "javaObjectType", -1, new KClassJavaObjectTypeProperty()); intrinsicsMap.registerIntrinsic(KOTLIN_JVM, StandardNames.FqNames.kClass, "javaObjectType", -1, new KClassJavaObjectTypeProperty());
@@ -104,7 +104,7 @@ public class IntrinsicMethods {
declareIntrinsicFunction(typeFqName, "dec", 0, DEC); declareIntrinsicFunction(typeFqName, "dec", 0, DEC);
} }
IntrinsicMethod hashCode = new HashCode(jvmTarget); IntrinsicMethod hashCode = new HashCode();
for (PrimitiveType type : PrimitiveType.values()) { for (PrimitiveType type : PrimitiveType.values()) {
FqName typeFqName = type.getTypeFqName(); FqName typeFqName = type.getTypeFqName();
Type wrapperType = AsmUtil.asmTypeByFqNameWithoutInnerClasses(JvmPrimitiveType.get(type).getWrapperFqName()); 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()); intrinsicsMap.registerIntrinsic(BUILT_INS_PACKAGE_FQ_NAME, null, "arrayOfNulls", 1, new NewArray());
for (PrimitiveType type : PrimitiveType.values()) { 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); declareIntrinsicFunction(COLLECTIONS_PACKAGE_FQ_NAME.child(Name.identifier(type.getTypeName().asString() + "Iterator")), "next", 0, ITERATOR_NEXT);
} }
declareArrayMethods(); declareArrayMethods();
if (jvmTarget.compareTo(JvmTarget.JVM_1_8) >= 0) { Java8UIntDivide java8UIntDivide = new Java8UIntDivide();
Java8UIntDivide java8UIntDivide = new Java8UIntDivide(); intrinsicsMap.registerIntrinsic(KOTLIN_UINT.toSafe(), null, "div", 1, java8UIntDivide);
intrinsicsMap.registerIntrinsic(KOTLIN_UINT.toSafe(), null, "div", 1, java8UIntDivide); intrinsicsMap.registerIntrinsic(BUILT_INS_PACKAGE_FQ_NAME, null, "uintDivide", 2, java8UIntDivide);
intrinsicsMap.registerIntrinsic(BUILT_INS_PACKAGE_FQ_NAME, null, "uintDivide", 2, java8UIntDivide);
Java8UIntRemainder java8UIntRemainder = new Java8UIntRemainder(); Java8UIntRemainder java8UIntRemainder = new Java8UIntRemainder();
intrinsicsMap.registerIntrinsic(KOTLIN_UINT.toSafe(), null, "rem", 1, java8UIntRemainder); intrinsicsMap.registerIntrinsic(KOTLIN_UINT.toSafe(), null, "rem", 1, java8UIntRemainder);
intrinsicsMap.registerIntrinsic(BUILT_INS_PACKAGE_FQ_NAME, null, "uintRemainder", 2, java8UIntRemainder); intrinsicsMap.registerIntrinsic(BUILT_INS_PACKAGE_FQ_NAME, null, "uintRemainder", 2, java8UIntRemainder);
Java8UIntCompare java8UIntCompare = new Java8UIntCompare(); Java8UIntCompare java8UIntCompare = new Java8UIntCompare();
intrinsicsMap.registerIntrinsic(KOTLIN_UINT.toSafe(), null, "compareTo", 1, java8UIntCompare); intrinsicsMap.registerIntrinsic(KOTLIN_UINT.toSafe(), null, "compareTo", 1, java8UIntCompare);
intrinsicsMap.registerIntrinsic(BUILT_INS_PACKAGE_FQ_NAME, null, "uintCompare", 2, 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(); Java8ULongDivide java8ULongDivide = new Java8ULongDivide();
intrinsicsMap.registerIntrinsic(KOTLIN_ULONG.toSafe(), null, "div", 1, java8ULongDivide); intrinsicsMap.registerIntrinsic(KOTLIN_ULONG.toSafe(), null, "div", 1, java8ULongDivide);
intrinsicsMap.registerIntrinsic(BUILT_INS_PACKAGE_FQ_NAME, null, "ulongDivide", 2, java8ULongDivide); intrinsicsMap.registerIntrinsic(BUILT_INS_PACKAGE_FQ_NAME, null, "ulongDivide", 2, java8ULongDivide);
Java8ULongRemainder java8ULongRemainder = new Java8ULongRemainder(); Java8ULongRemainder java8ULongRemainder = new Java8ULongRemainder();
intrinsicsMap.registerIntrinsic(KOTLIN_ULONG.toSafe(), null, "rem", 1, java8ULongRemainder); intrinsicsMap.registerIntrinsic(KOTLIN_ULONG.toSafe(), null, "rem", 1, java8ULongRemainder);
intrinsicsMap.registerIntrinsic(BUILT_INS_PACKAGE_FQ_NAME, null, "ulongRemainder", 2, java8ULongRemainder); intrinsicsMap.registerIntrinsic(BUILT_INS_PACKAGE_FQ_NAME, null, "ulongRemainder", 2, java8ULongRemainder);
Java8ULongCompare java8ULongCompare = new Java8ULongCompare(); Java8ULongCompare java8ULongCompare = new Java8ULongCompare();
intrinsicsMap.registerIntrinsic(KOTLIN_ULONG.toSafe(), null, "compareTo", 1, java8ULongCompare); intrinsicsMap.registerIntrinsic(KOTLIN_ULONG.toSafe(), null, "compareTo", 1, java8ULongCompare);
intrinsicsMap.registerIntrinsic(BUILT_INS_PACKAGE_FQ_NAME, null, "ulongCompare", 2, 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() { private void declareArrayMethods() {
compiler/backend/src/org/jetbrains/kotlin/codegen/state/GenerationState.kt
+14 -19
View File
@@ -37,7 +37,10 @@ import org.jetbrains.kotlin.psi.KtClassOrObject
import org.jetbrains.kotlin.psi.KtCodeFragment import org.jetbrains.kotlin.psi.KtCodeFragment
import org.jetbrains.kotlin.psi.KtFile import org.jetbrains.kotlin.psi.KtFile
import org.jetbrains.kotlin.psi.KtScript 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.deprecation.DeprecationResolver
import org.jetbrains.kotlin.resolve.diagnostics.Diagnostics import org.jetbrains.kotlin.resolve.diagnostics.Diagnostics
import org.jetbrains.kotlin.resolve.diagnostics.OnDemandSuppressCache import org.jetbrains.kotlin.resolve.diagnostics.OnDemandSuppressCache
@@ -241,26 +244,18 @@ class GenerationState private constructor(
configuration.get(JVMConfigurationKeys.STRING_CONCAT) ?: JvmStringConcat.INDY_WITH_CONSTANTS configuration.get(JVMConfigurationKeys.STRING_CONCAT) ?: JvmStringConcat.INDY_WITH_CONSTANTS
else JvmStringConcat.INLINE else JvmStringConcat.INLINE
val samConversionsScheme = run { val samConversionsScheme: JvmClosureGenerationScheme =
val fromConfig = configuration.get(JVMConfigurationKeys.SAM_CONVERSIONS) configuration.get(JVMConfigurationKeys.SAM_CONVERSIONS)
if (fromConfig != null && target >= fromConfig.minJvmTarget) ?: if (languageVersionSettings.supportsFeature(LanguageFeature.SamWrapperClassesAreSynthetic))
fromConfig JvmClosureGenerationScheme.INDY
else if ( else
target >= JvmClosureGenerationScheme.INDY.minJvmTarget && JvmClosureGenerationScheme.CLASS
languageVersionSettings.supportsFeature(LanguageFeature.SamWrapperClassesAreSynthetic)
)
JvmClosureGenerationScheme.INDY
else
JvmClosureGenerationScheme.CLASS
}
val lambdasScheme = configuration.get(JVMConfigurationKeys.LAMBDAS).let { fromConfig -> val lambdasScheme: JvmClosureGenerationScheme =
if (fromConfig == null || target < fromConfig.minJvmTarget) { configuration.get(JVMConfigurationKeys.LAMBDAS)
if (languageVersionSettings.supportsFeature(LanguageFeature.LightweightLambdas) && target >= JvmClosureGenerationScheme.INDY.minJvmTarget) ?: if (languageVersionSettings.supportsFeature(LanguageFeature.LightweightLambdas))
JvmClosureGenerationScheme.INDY JvmClosureGenerationScheme.INDY
else JvmClosureGenerationScheme.CLASS else JvmClosureGenerationScheme.CLASS
} else fromConfig
}
val moduleName: String = moduleName ?: JvmCodegenUtil.getModuleName(module) val moduleName: String = moduleName ?: JvmCodegenUtil.getModuleName(module)
val classBuilderMode: ClassBuilderMode = builderFactory.classBuilderMode val classBuilderMode: ClassBuilderMode = builderFactory.classBuilderMode
@@ -280,7 +275,7 @@ class GenerationState private constructor(
isIrBackend isIrBackend
) )
val canReplaceStdlibRuntimeApiBehavior = languageVersionSettings.apiVersion <= ApiVersion.parse(KotlinVersion.CURRENT.toString())!! val canReplaceStdlibRuntimeApiBehavior = languageVersionSettings.apiVersion <= ApiVersion.parse(KotlinVersion.CURRENT.toString())!!
val intrinsics: IntrinsicMethods = IntrinsicMethods(target, canReplaceStdlibRuntimeApiBehavior) val intrinsics: IntrinsicMethods = IntrinsicMethods(canReplaceStdlibRuntimeApiBehavior)
val generateOptimizedCallableReferenceSuperClasses = val generateOptimizedCallableReferenceSuperClasses =
languageVersionSettings.apiVersion >= ApiVersion.KOTLIN_1_4 && languageVersionSettings.apiVersion >= ApiVersion.KOTLIN_1_4 &&
!configuration.getBoolean(JVMConfigurationKeys.NO_OPTIMIZED_CALLABLE_REFERENCES) !configuration.getBoolean(JVMConfigurationKeys.NO_OPTIMIZED_CALLABLE_REFERENCES)
compiler/backend/src/org/jetbrains/kotlin/codegen/state/KotlinTypeMapper.kt
+1 -2
View File
@@ -574,8 +574,7 @@ class KotlinTypeMapper @JvmOverloads constructor(
mapDefaultCallback(baseMethodDescriptor, getKindForDefaultImplCall(baseMethodDescriptor)), mapDefaultCallback(baseMethodDescriptor, getKindForDefaultImplCall(baseMethodDescriptor)),
signature, invokeOpcode, thisClass, dispatchReceiverKotlinType, receiverParameterType, extensionReceiverKotlinType, signature, invokeOpcode, thisClass, dispatchReceiverKotlinType, receiverParameterType, extensionReceiverKotlinType,
calleeType, returnKotlinType, calleeType, returnKotlinType,
if (jvmTarget >= JvmTarget.JVM_1_8) isInterfaceMember else invokeOpcode == INVOKEINTERFACE, isInterfaceMember, isDefaultMethodInInterface, boxInlineClassBeforeInvoke
isDefaultMethodInInterface, boxInlineClassBeforeInvoke
) )
} }
compiler/cli/src/org/jetbrains/kotlin/cli/jvm/jvmArguments.kt
+13 -29
View File
@@ -77,14 +77,6 @@ fun CompilerConfiguration.setupJvmSpecificArguments(arguments: K2JVMCompilerArgu
val jvmDefaultMode = languageVersionSettings.getFlag(JvmAnalysisFlags.jvmDefaultMode) val jvmDefaultMode = languageVersionSettings.getFlag(JvmAnalysisFlags.jvmDefaultMode)
val jvmTarget = get(JVMConfigurationKeys.JVM_TARGET) ?: JvmTarget.DEFAULT 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) { if (jvmDefaultMode == JvmDefaultMode.ENABLE || jvmDefaultMode == JvmDefaultMode.ENABLE_WITH_DEFAULT_IMPLS) {
messageCollector.report( messageCollector.report(
@@ -112,8 +104,8 @@ fun CompilerConfiguration.setupJvmSpecificArguments(arguments: K2JVMCompilerArgu
} }
} }
handleClosureGenerationSchemeArgument("-Xsam-conversions", arguments.samConversions, JVMConfigurationKeys.SAM_CONVERSIONS, jvmTarget) handleClosureGenerationSchemeArgument("-Xsam-conversions", arguments.samConversions, JVMConfigurationKeys.SAM_CONVERSIONS)
handleClosureGenerationSchemeArgument("-Xlambdas", arguments.lambdas, JVMConfigurationKeys.LAMBDAS, jvmTarget) handleClosureGenerationSchemeArgument("-Xlambdas", arguments.lambdas, JVMConfigurationKeys.LAMBDAS)
addAll(JVMConfigurationKeys.ADDITIONAL_JAVA_MODULES, arguments.additionalJavaModules?.asList()) addAll(JVMConfigurationKeys.ADDITIONAL_JAVA_MODULES, arguments.additionalJavaModules?.asList())
} }
@@ -122,26 +114,18 @@ private fun CompilerConfiguration.handleClosureGenerationSchemeArgument(
flag: String, flag: String,
value: String?, value: String?,
key: CompilerConfigurationKey<JvmClosureGenerationScheme>, key: CompilerConfigurationKey<JvmClosureGenerationScheme>,
jvmTarget: JvmTarget
) { ) {
if (value != null) { if (value == null) return
val parsedValue = JvmClosureGenerationScheme.fromString(value)
if (parsedValue != null) { val parsedValue = JvmClosureGenerationScheme.fromString(value)
put(key, parsedValue) if (parsedValue != null) {
if (jvmTarget < parsedValue.minJvmTarget) { put(key, parsedValue)
messageCollector.report( } else {
WARNING, messageCollector.report(
"`$flag=$value` requires JVM target at least " + ERROR,
"${parsedValue.minJvmTarget.description} and is ignored." "Unknown `$flag` argument: ${value}\n." +
) "Supported arguments: ${JvmClosureGenerationScheme.values().joinToString { it.description }}"
} )
} else {
messageCollector.report(
ERROR,
"Unknown `$flag` argument: ${value}\n." +
"Supported arguments: ${JvmClosureGenerationScheme.values().joinToString { it.description }}"
)
}
} }
} }
compiler/config.jvm/src/org/jetbrains/kotlin/config/JvmClosureGenerationScheme.kt
+3 -6
View File
@@ -7,12 +7,9 @@ package org.jetbrains.kotlin.config
import org.jetbrains.kotlin.util.capitalizeDecapitalize.toLowerCaseAsciiOnly import org.jetbrains.kotlin.util.capitalizeDecapitalize.toLowerCaseAsciiOnly
enum class JvmClosureGenerationScheme( enum class JvmClosureGenerationScheme(val description: String) {
val description: String, CLASS("class"),
val minJvmTarget: JvmTarget INDY("indy"),
) {
CLASS("class", JvmTarget.JVM_1_6),
INDY("indy", JvmTarget.JVM_1_8),
; ;
companion object { companion object {
compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/AnnotationCodegen.kt
+39 -43
View File
@@ -28,7 +28,6 @@ import org.jetbrains.kotlin.codegen.AsmUtil
import org.jetbrains.kotlin.codegen.TypeAnnotationCollector import org.jetbrains.kotlin.codegen.TypeAnnotationCollector
import org.jetbrains.kotlin.codegen.TypePathInfo import org.jetbrains.kotlin.codegen.TypePathInfo
import org.jetbrains.kotlin.config.JVMConfigurationKeys 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.DescriptorVisibilities
import org.jetbrains.kotlin.descriptors.annotations.KotlinRetention import org.jetbrains.kotlin.descriptors.annotations.KotlinRetention
import org.jetbrains.kotlin.descriptors.annotations.KotlinTarget import org.jetbrains.kotlin.descriptors.annotations.KotlinTarget
@@ -292,50 +291,48 @@ abstract class AnnotationCodegen(
boundType: Int, boundType: Int,
visitor: (typeRef: Int, typePath: TypePath?, descriptor: String, visible: Boolean) -> AnnotationVisitor visitor: (typeRef: Int, typePath: TypePath?, descriptor: String, visible: Boolean) -> AnnotationVisitor
) { ) {
if (context.state.target != JVM_1_6) { typeParameterContainer.typeParameters.forEachIndexed { index, typeParameter ->
typeParameterContainer.typeParameters.forEachIndexed { index, typeParameter -> object : AnnotationCodegen(classCodegen, true) {
object : AnnotationCodegen(classCodegen, true) { override fun visitAnnotation(descr: String, visible: Boolean): AnnotationVisitor {
override fun visitAnnotation(descr: String, visible: Boolean): AnnotationVisitor {
return visitor( return visitor(
TypeReference.newTypeParameterReference(referenceType, index).value, TypeReference.newTypeParameterReference(referenceType, index).value,
null, null,
descr, descr,
visible visible
) )
} }
override fun visitTypeAnnotation(descr: String, path: TypePath?, visible: Boolean): AnnotationVisitor { override fun visitTypeAnnotation(descr: String, path: TypePath?, visible: Boolean): AnnotationVisitor {
throw RuntimeException( throw RuntimeException(
"Error during generation: type annotation shouldn't be presented on type parameter: " + "Error during generation: type annotation shouldn't be presented on type parameter: " +
"${ir2string(typeParameter)} in ${ir2string(typeParameterContainer)}" "${ir2string(typeParameter)} in ${ir2string(typeParameterContainer)}"
) )
} }
}.genAnnotations(typeParameter, null, null) }.genAnnotations(typeParameter, null, null)
if (context.state.configuration.getBoolean(JVMConfigurationKeys.EMIT_JVM_TYPE_ANNOTATIONS)) { if (context.state.configuration.getBoolean(JVMConfigurationKeys.EMIT_JVM_TYPE_ANNOTATIONS)) {
var superInterfaceIndex = 1 var superInterfaceIndex = 1
typeParameter.superTypes.forEach { superType -> typeParameter.superTypes.forEach { superType ->
val isClassOrTypeParameter = !superType.isInterface() && !superType.isAnnotation() val isClassOrTypeParameter = !superType.isInterface() && !superType.isAnnotation()
val superIndex = if (isClassOrTypeParameter) 0 else superInterfaceIndex++ val superIndex = if (isClassOrTypeParameter) 0 else superInterfaceIndex++
object : AnnotationCodegen(classCodegen, true) { object : AnnotationCodegen(classCodegen, true) {
override fun visitAnnotation(descr: String, visible: Boolean): AnnotationVisitor { override fun visitAnnotation(descr: String, visible: Boolean): AnnotationVisitor {
throw RuntimeException( throw RuntimeException(
"Error during generation: only type annotations should be presented on type parameters bounds: " + "Error during generation: only type annotations should be presented on type parameters bounds: " +
"${ir2string(typeParameter)} in ${ir2string(typeParameter)}" "${ir2string(typeParameter)} in ${ir2string(typeParameter)}"
) )
} }
override fun visitTypeAnnotation(descr: String, path: TypePath?, visible: Boolean): AnnotationVisitor { override fun visitTypeAnnotation(descr: String, path: TypePath?, visible: Boolean): AnnotationVisitor {
return visitor( return visitor(
TypeReference.newTypeParameterBoundReference(boundType, index, superIndex).value, TypeReference.newTypeParameterBoundReference(boundType, index, superIndex).value,
path, path,
descr, descr,
visible visible
) )
} }
}.generateTypeAnnotations(typeParameterContainer, superType) }.generateTypeAnnotations(typeParameterContainer, superType)
}
} }
} }
} }
@@ -401,8 +398,7 @@ abstract class AnnotationCodegen(
type: IrType? type: IrType?
) { ) {
if ((annotated as? IrDeclaration)?.origin == JvmLoweredDeclarationOrigin.SYNTHETIC_ACCESSOR || if ((annotated as? IrDeclaration)?.origin == JvmLoweredDeclarationOrigin.SYNTHETIC_ACCESSOR ||
type == null || context.state.target === JVM_1_6 || type == null || !context.state.configuration.getBoolean(JVMConfigurationKeys.EMIT_JVM_TYPE_ANNOTATIONS)
!context.state.configuration.getBoolean(JVMConfigurationKeys.EMIT_JVM_TYPE_ANNOTATIONS)
) { ) {
return return
} }
compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/CompareTo.kt
+3 -11
View File
@@ -27,7 +27,6 @@ import org.jetbrains.kotlin.codegen.AsmUtil.comparisonOperandType
import org.jetbrains.kotlin.codegen.BranchedValue import org.jetbrains.kotlin.codegen.BranchedValue
import org.jetbrains.kotlin.codegen.NumberCompare import org.jetbrains.kotlin.codegen.NumberCompare
import org.jetbrains.kotlin.codegen.ObjectCompare import org.jetbrains.kotlin.codegen.ObjectCompare
import org.jetbrains.kotlin.config.JvmTarget
import org.jetbrains.kotlin.config.LanguageFeature import org.jetbrains.kotlin.config.LanguageFeature
import org.jetbrains.kotlin.ir.expressions.IrFunctionAccessExpression import org.jetbrains.kotlin.ir.expressions.IrFunctionAccessExpression
import org.jetbrains.kotlin.lexer.KtSingleValueToken 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 import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter
object CompareTo : IntrinsicMethod() { object CompareTo : IntrinsicMethod() {
private fun genInvoke(type: Type?, v: InstructionAdapter, classCodegen: ClassCodegen) { private fun genInvoke(type: Type?, v: InstructionAdapter) {
when (type) { when (type) {
Type.CHAR_TYPE, Type.BYTE_TYPE, Type.SHORT_TYPE, Type.INT_TYPE -> Type.CHAR_TYPE, Type.BYTE_TYPE, Type.SHORT_TYPE, Type.INT_TYPE ->
v.invokestatic(JvmSymbols.INTRINSICS_CLASS_NAME, "compare", "(II)I", false) v.invokestatic(JvmSymbols.INTRINSICS_CLASS_NAME, "compare", "(II)I", false)
Type.LONG_TYPE -> v.invokestatic(JvmSymbols.INTRINSICS_CLASS_NAME, "compare", "(JJ)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.FLOAT_TYPE -> v.invokestatic("java/lang/Float", "compare", "(FF)I", false)
Type.DOUBLE_TYPE -> v.invokestatic("java/lang/Double", "compare", "(DD)I", false) Type.DOUBLE_TYPE -> v.invokestatic("java/lang/Double", "compare", "(DD)I", false)
Type.BOOLEAN_TYPE -> { Type.BOOLEAN_TYPE -> v.invokestatic("java/lang/Boolean", "compare", "(ZZ)I", false)
// 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)
}
else -> throw UnsupportedOperationException() else -> throw UnsupportedOperationException()
} }
} }
@@ -70,7 +62,7 @@ object CompareTo : IntrinsicMethod() {
signature.valueParameters.single().asmType, signature.valueParameters.single().asmType,
) )
return IrIntrinsicFunction.create(expression, signature, classCodegen, listOf(parameterType, parameterType)) { return IrIntrinsicFunction.create(expression, signature, classCodegen, listOf(parameterType, parameterType)) {
genInvoke(parameterType, it, classCodegen) genInvoke(parameterType, it)
} }
} }
} }
compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/HashCode.kt
+1 -2
View File
@@ -20,7 +20,6 @@ import org.jetbrains.kotlin.backend.jvm.JvmLoweredDeclarationOrigin
import org.jetbrains.kotlin.backend.jvm.codegen.* import org.jetbrains.kotlin.backend.jvm.codegen.*
import org.jetbrains.kotlin.codegen.AsmUtil import org.jetbrains.kotlin.codegen.AsmUtil
import org.jetbrains.kotlin.codegen.DescriptorAsmUtil import org.jetbrains.kotlin.codegen.DescriptorAsmUtil
import org.jetbrains.kotlin.config.JvmTarget
import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin
import org.jetbrains.kotlin.ir.expressions.IrFunctionAccessExpression import org.jetbrains.kotlin.ir.expressions.IrFunctionAccessExpression
import org.jetbrains.kotlin.ir.util.render 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'? // TODO generate or lower IR for data class / value class 'hashCode'?
DescriptorAsmUtil.genHashCode(mv, mv, receiverType, target) DescriptorAsmUtil.genHashCode(mv, mv, receiverType, target)
} }
target >= JvmTarget.JVM_1_8 && AsmUtil.isPrimitive(receiverJvmType) -> { AsmUtil.isPrimitive(receiverJvmType) -> {
val boxedType = AsmUtil.boxPrimitiveType(receiverJvmType) val boxedType = AsmUtil.boxPrimitiveType(receiverJvmType)
?: throw AssertionError("Primitive type expected: $receiverJvmType") ?: throw AssertionError("Primitive type expected: $receiverJvmType")
receiverValue.materializeAt(receiverJvmType, receiverIrType) receiverValue.materializeAt(receiverJvmType, receiverIrType)
compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmBuiltInsLowering.kt
+11 -15
View File
@@ -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.JvmBackendContext
import org.jetbrains.kotlin.backend.jvm.ir.createJvmIrBuilder import org.jetbrains.kotlin.backend.jvm.ir.createJvmIrBuilder
import org.jetbrains.kotlin.backend.jvm.ir.irArrayOf 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.declarations.IrFile
import org.jetbrains.kotlin.ir.expressions.IrCall import org.jetbrains.kotlin.ir.expressions.IrCall
import org.jetbrains.kotlin.ir.expressions.IrExpression import org.jetbrains.kotlin.ir.expressions.IrExpression
@@ -36,22 +35,19 @@ class JvmBuiltInsLowering(val context: JvmBackendContext) : FileLoweringPass {
expression.transformChildren(this, null) expression.transformChildren(this, null)
val callee = expression.symbol.owner val callee = expression.symbol.owner
val parentClassName = callee.parent.fqNameForIrSerialization.asString()
if (context.state.target >= JvmTarget.JVM_1_8) { val functionName = callee.name.asString()
val parentClassName = callee.parent.fqNameForIrSerialization.asString() if (parentClassName == "kotlin.CompareToKt" && functionName == "compareTo") {
val functionName = callee.name.asString() val operandType = expression.getValueArgument(0)!!.type
if (parentClassName == "kotlin.CompareToKt" && functionName == "compareTo") { when {
val operandType = expression.getValueArgument(0)!!.type operandType.isUInt() -> return expression.replaceWithCallTo(context.ir.symbols.compareUnsignedInt)
when { operandType.isULong() -> return expression.replaceWithCallTo(context.ir.symbols.compareUnsignedLong)
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 jvm8Replacement = jvm8builtInReplacements[parentClassName to functionName]
if (jvm8Replacement != null) {
return expression.replaceWithCallTo(jvm8Replacement)
}
return when { return when {
callee.isArrayOf() -> callee.isArrayOf() ->
compiler/light-classes/src/org/jetbrains/kotlin/asJava/elements/KtLightModifierListDescriptorBased.kt
+1 -1
View File
@@ -89,7 +89,7 @@ abstract class KtUltraLightModifierList<out T : KtLightElement<KtModifierListOwn
sourceAnnotations.mapNotNullTo(result) { sourceAnnotation -> sourceAnnotations.mapNotNullTo(result) { sourceAnnotation ->
sourceAnnotation.additionalConverter() sourceAnnotation.additionalConverter()
?: sourceAnnotation.tryConvertAsTarget(support) ?: sourceAnnotation.tryConvertAsTarget()
?: sourceAnnotation.tryConvertAsRetention() ?: sourceAnnotation.tryConvertAsRetention()
?: sourceAnnotation.tryConvertAsRepeatable(owner) ?: sourceAnnotation.tryConvertAsRepeatable(owner)
?: sourceAnnotation.tryConvertAsMustBeDocumented() ?: sourceAnnotation.tryConvertAsMustBeDocumented()
compiler/light-classes/src/org/jetbrains/kotlin/asJava/elements/KtToJvmAnnotationsConverter.kt
+6 -15
View File
@@ -8,9 +8,7 @@ package org.jetbrains.kotlin.asJava.elements
import com.intellij.psi.* import com.intellij.psi.*
import com.intellij.psi.CommonClassNames.* import com.intellij.psi.CommonClassNames.*
import org.jetbrains.kotlin.asJava.classes.KtUltraLightSimpleAnnotation 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.builtins.StandardNames.FqNames
import org.jetbrains.kotlin.config.JvmTarget
import org.jetbrains.kotlin.load.java.JvmAbi import org.jetbrains.kotlin.load.java.JvmAbi
import org.jetbrains.kotlin.load.java.JvmAnnotationNames import org.jetbrains.kotlin.load.java.JvmAnnotationNames
import org.jetbrains.kotlin.name.ClassId 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.EnumValue
import org.jetbrains.kotlin.resolve.constants.KClassValue import org.jetbrains.kotlin.resolve.constants.KClassValue
import org.jetbrains.kotlin.utils.addToStdlib.safeAs import org.jetbrains.kotlin.utils.addToStdlib.safeAs
import java.util.*
internal const val KOTLIN_JVM_INTERNAL_REPEATABLE_CONTAINER = "kotlin.jvm.internal.RepeatableContainer" 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}" } .map { "${it.first.asSingleFqName().asString()}.${it.second.identifier}" }
} }
private val targetMappings = EnumMap<JvmTarget, Map<String, EnumValue>>(JvmTarget::class.java).also { result -> private val targetMapping = run {
val javaAnnotationElementTypeId = ClassId.fromString(JvmAnnotationNames.ELEMENT_TYPE_ENUM.asString()) 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.CLASS" to EnumValue(javaAnnotationElementTypeId, Name.identifier("TYPE")),
"kotlin.annotation.AnnotationTarget.ANNOTATION_CLASS" to EnumValue(javaAnnotationElementTypeId, Name.identifier("ANNOTATION_TYPE")), "kotlin.annotation.AnnotationTarget.ANNOTATION_CLASS" to EnumValue(javaAnnotationElementTypeId, Name.identifier("ANNOTATION_TYPE")),
"kotlin.annotation.AnnotationTarget.FIELD" to EnumValue(javaAnnotationElementTypeId, Name.identifier("FIELD")), "kotlin.annotation.AnnotationTarget.FIELD" to EnumValue(javaAnnotationElementTypeId, Name.identifier("FIELD")),
@@ -67,18 +64,13 @@ private val targetMappings = EnumMap<JvmTarget, Map<String, EnumValue>>(JvmTarge
"kotlin.annotation.AnnotationTarget.CONSTRUCTOR" to EnumValue(javaAnnotationElementTypeId, Name.identifier("CONSTRUCTOR")), "kotlin.annotation.AnnotationTarget.CONSTRUCTOR" to EnumValue(javaAnnotationElementTypeId, Name.identifier("CONSTRUCTOR")),
"kotlin.annotation.AnnotationTarget.FUNCTION" to EnumValue(javaAnnotationElementTypeId, Name.identifier("METHOD")), "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_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 if (FqNames.target.asString() != qualifiedName) return null
@@ -87,7 +79,6 @@ internal fun PsiAnnotation.tryConvertAsTarget(support: KtUltraLightSupport): KtL
attributeValues ?: return null attributeValues ?: return null
val targetMapping = targetMappings.getValue(support.jvmTarget)
val convertedValues = attributeValues.mapNotNull { targetMapping[it] }.distinct() val convertedValues = attributeValues.mapNotNull { targetMapping[it] }.distinct()
val targetAttributes = "value" to ArrayValue(convertedValues) { module -> module.builtIns.array.defaultType } val targetAttributes = "value" to ArrayValue(convertedValues) { module -> module.builtIns.array.defaultType }
compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/test/util/KtTestUtil.java
-5
View File
@@ -144,11 +144,6 @@ public class KtTestUtil {
return System.getenv(propertyName); return System.getenv(propertyName);
} }
@NotNull
public static File getJdk6Home() {
return getJdkHome("JDK_1_6", "JDK_6", "JDK_16");
}
@NotNull @NotNull
public static File getJdk8Home() { public static File getJdk8Home() {
return getJdkHome("JDK_1_8", "JDK_8", "JDK_18"); return getJdkHome("JDK_1_8", "JDK_8", "JDK_18");
compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/classic/JavaCompilerFacade.kt
+1 -3
View File
@@ -65,8 +65,7 @@ class JavaCompilerFacade(private val testServices: TestServices) {
} }
private fun compileJavaFiles(module: TestModule, jvmTarget: JvmTarget, files: List<File>, javacOptions: List<String>, ignoreErrors: Boolean) { private fun compileJavaFiles(module: TestModule, jvmTarget: JvmTarget, files: List<File>, javacOptions: List<String>, 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) {
if (USE_JAVAC_BASED_ON_JVM_TARGET !in module.directives || targetIsJava8OrLower) {
org.jetbrains.kotlin.test.compileJavaFiles( org.jetbrains.kotlin.test.compileJavaFiles(
files, files,
javacOptions, javacOptions,
@@ -76,7 +75,6 @@ class JavaCompilerFacade(private val testServices: TestServices) {
return return
} }
val jdkHome = when (jvmTarget) { val jdkHome = when (jvmTarget) {
JvmTarget.JVM_1_6 -> KtTestUtil.getJdk6Home()
JvmTarget.JVM_1_8 -> KtTestUtil.getJdk8Home() JvmTarget.JVM_1_8 -> KtTestUtil.getJdk8Home()
JvmTarget.JVM_9, JvmTarget.JVM_9,
JvmTarget.JVM_11 -> KtTestUtil.getJdk11Home() JvmTarget.JVM_11 -> KtTestUtil.getJdk11Home()
compiler/tests-compiler-utils/tests/org/jetbrains/kotlin/codegen/CodegenTestUtil.java
+1 -1
View File
@@ -188,7 +188,7 @@ public class CodegenTestUtil {
public static String computeJavaTarget(@NotNull List<String> javacOptions, @Nullable JvmTarget kotlinTarget) { public static String computeJavaTarget(@NotNull List<String> javacOptions, @Nullable JvmTarget kotlinTarget) {
if (JAVA_COMPILATION_TARGET != null && !javacOptions.contains("-target")) if (JAVA_COMPILATION_TARGET != null && !javacOptions.contains("-target"))
return JAVA_COMPILATION_TARGET; return JAVA_COMPILATION_TARGET;
if (kotlinTarget != null && kotlinTarget.compareTo(JvmTarget.JVM_1_6) > 0) if (kotlinTarget != null)
return kotlinTarget.getDescription(); return kotlinTarget.getDescription();
if (IS_SOURCE_6_STILL_SUPPORTED) if (IS_SOURCE_6_STILL_SUPPORTED)
return "1.6"; return "1.6";
compiler/tests-java8/tests/org/jetbrains/kotlin/jvm/repl/ReplCompilerJava8Test.kt
-1
View File
@@ -56,7 +56,6 @@ class ReplCompilerJava8Test : KtUsefulTestCase() {
put(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY, PrintingMessageCollector(System.out, MessageRenderer.WITHOUT_PATHS, false)) put(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY, PrintingMessageCollector(System.out, MessageRenderer.WITHOUT_PATHS, false))
addKotlinSourceRoot(tmpdir.absolutePath) addKotlinSourceRoot(tmpdir.absolutePath)
put(JVMConfigurationKeys.OUTPUT_DIRECTORY, tmpdir) put(JVMConfigurationKeys.OUTPUT_DIRECTORY, tmpdir)
put(JVMConfigurationKeys.JVM_TARGET, JvmTarget.JVM_1_8)
loadScriptingPlugin(this) loadScriptingPlugin(this)
} }
compiler/tests/org/jetbrains/kotlin/serialization/JvmVersionRequirementTest.kt
-1
View File
@@ -43,7 +43,6 @@ class JvmVersionRequirementTest : AbstractVersionRequirementTest() {
KotlinCoreEnvironment.createForTests( KotlinCoreEnvironment.createForTests(
testRootDisposable, testRootDisposable,
KotlinTestUtils.newConfiguration(ConfigurationKind.ALL, TestJdkKind.MOCK_JDK, outputDirectory).apply { KotlinTestUtils.newConfiguration(ConfigurationKind.ALL, TestJdkKind.MOCK_JDK, outputDirectory).apply {
put(JVMConfigurationKeys.JVM_TARGET, JvmTarget.JVM_1_8)
languageVersionSettings = LanguageVersionSettingsImpl( languageVersionSettings = LanguageVersionSettingsImpl(
languageVersion, languageVersion,
ApiVersion.createByLanguageVersion(languageVersion), ApiVersion.createByLanguageVersion(languageVersion),