From 72d048bd626e2ada068173448c38853ef5840293 Mon Sep 17 00:00:00 2001 From: Alexander Udalov Date: Fri, 21 Jul 2023 18:18:42 +0200 Subject: [PATCH] JVM: introduce JvmBackendConfig Move language version settings, compiler configuration and different flags there, and use this config everywhere in both backends instead of GenerationState. This will hopefully make GenerationState less of a "god object" and remove the need to have it available everywhere, in particular in JVM IR lowerings code, in the future. Also, future refactorings will make it easier to inject backend-specific behavior into common code, so that we would not need to handle support of new features in the old backend. --- .../kotlin/codegen/ClassFileFactory.java | 2 +- .../kotlin/codegen/ClosureCodegen.java | 2 +- .../kotlin/codegen/CodeFragmentCodegen.kt | 2 +- .../kotlin/codegen/DescriptorAsmUtil.java | 11 +- .../kotlin/codegen/ExpressionCodegen.java | 33 +++--- .../FunctionsFromAnyGeneratorImpl.java | 2 +- .../codegen/ImplementationBodyCodegen.java | 4 +- .../codegen/InterfaceImplBodyCodegen.kt | 6 +- .../kotlin/codegen/MemberCodegen.java | 12 +- .../kotlin/codegen/MultifileClassCodegen.kt | 4 +- .../codegen/MultifileClassPartCodegen.kt | 2 +- .../kotlin/codegen/PackagePartCodegen.java | 2 +- .../kotlin/codegen/PropertyCodegen.java | 2 +- .../codegen/PropertyReferenceCodegen.kt | 2 +- .../kotlin/codegen/SamWrapperCodegen.java | 4 +- .../jetbrains/kotlin/codegen/ScriptCodegen.kt | 2 +- .../jetbrains/kotlin/codegen/StackValue.java | 2 +- .../kotlin/codegen/StringConcatGenerator.kt | 4 +- .../jetbrains/kotlin/codegen/codegenUtil.kt | 4 +- .../codegen/generateJava8ParameterNames.kt | 2 +- .../inline/AnonymousObjectTransformer.kt | 6 +- .../kotlin/codegen/inline/MethodInliner.kt | 2 +- .../codegen/inline/ObjectTransformer.kt | 6 +- .../kotlin/codegen/inline/PsiInlineCodegen.kt | 2 +- .../inline/PsiInlineIntrinsicsSupport.kt | 2 +- .../codegen/inline/SamWrapperTransformer.kt | 6 +- .../inline/coroutines/CoroutineTransformer.kt | 2 +- .../jetbrains/kotlin/codegen/inline/typeOf.kt | 2 +- .../codegen/optimization/MethodVerifier.kt | 2 +- .../optimization/OptimizationMethodVisitor.kt | 2 +- .../serialization/JvmSerializerExtension.kt | 12 +- .../kotlin/codegen/state/GenerationState.kt | 99 ++--------------- .../kotlin/codegen/state/JvmBackendConfig.kt | 103 ++++++++++++++++++ .../MappingClassesForWhenByEnumCodegen.java | 4 +- .../codegen/when/SwitchCodegenProvider.kt | 4 +- .../kotlin/codegen/writeAnnotationUtil.kt | 4 +- .../backend/jvm/FirJvmSerializerExtension.kt | 4 +- .../backend/jvm/codegen/ClassCodegen.kt | 10 +- .../backend/jvm/codegen/ExpressionCodegen.kt | 14 +-- .../backend/jvm/codegen/FunctionCodegen.kt | 2 +- .../jvm/codegen/IrInlineIntrinsicsSupport.kt | 2 +- .../kotlin/backend/jvm/intrinsics/HashCode.kt | 2 +- .../backend/jvm/intrinsics/IrCheckNotNull.kt | 2 +- .../ThrowKotlinNothingValueException.kt | 4 +- .../AdditionalClassAnnotationLowering.kt | 2 +- .../backend/jvm/lower/AssertionLowering.kt | 4 +- .../backend/jvm/lower/BridgeLowering.kt | 8 +- .../jvm/lower/FunctionReferenceLowering.kt | 6 +- ...nheritedDefaultMethodsOnClassesLowering.kt | 8 +- .../backend/jvm/lower/InterfaceLowering.kt | 2 +- ...vmArgumentNullabilityAssertionsLowering.kt | 6 +- .../jvm/lower/JvmPropertiesLowering.kt | 2 +- .../lower/JvmStringConcatenationLowering.kt | 2 +- .../lower/JvmValueClassAbstractLowering.kt | 8 +- .../PropertyReferenceDelegationLowering.kt | 2 +- .../jvm/lower/PropertyReferenceLowering.kt | 4 +- .../SingletonOrConstantDelegationLowering.kt | 2 +- .../backend/jvm/lower/TypeOperatorLowering.kt | 7 +- .../lower/indy/LambdaMetafactoryArguments.kt | 6 +- .../kotlin/backend/jvm/lower/irValidation.kt | 4 +- .../kotlin/backend/jvm/JvmBackendContext.kt | 5 +- .../kotlin/backend/jvm/JvmSymbols.kt | 2 +- .../jvm/MemoizedInlineClassReplacements.kt | 2 +- ...emoizedMultiFieldValueClassReplacements.kt | 2 +- .../MemoizedValueClassAbstractReplacements.kt | 2 +- .../kotlin/backend/jvm/ir/JvmIrInlineUtils.kt | 2 +- .../jvm/mapping/MethodSignatureMapper.kt | 4 +- .../metadata/DescriptorMetadataSerializer.kt | 2 +- .../parcel/ParcelableCodegenExtension.kt | 2 +- .../compiler/backend/jvm/JVMCodegenUtil.kt | 4 +- 70 files changed, 265 insertions(+), 237 deletions(-) create mode 100644 compiler/backend/src/org/jetbrains/kotlin/codegen/state/JvmBackendConfig.kt diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/ClassFileFactory.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/ClassFileFactory.java index fe212fc70ce..8e22a03355f 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/ClassFileFactory.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/ClassFileFactory.java @@ -144,7 +144,7 @@ public class ClassFileFactory implements OutputFileCollection { if (state.getLanguageVersionSettings().getFlag(JvmAnalysisFlags.getStrictMetadataVersionSemantics())) { flags |= ModuleMapping.STRICT_METADATA_VERSION_SEMANTICS_FLAG; } - return ModuleMappingKt.serializeToByteArray(moduleProto, state.getMetadataVersion(), flags); + return ModuleMappingKt.serializeToByteArray(moduleProto, state.getConfig().getMetadataVersion(), flags); } @Override diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/ClosureCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/ClosureCodegen.java index 39a93993f86..f3ea860cc90 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/ClosureCodegen.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/ClosureCodegen.java @@ -173,7 +173,7 @@ public class ClosureCodegen extends MemberCodegen { v.defineClass( element, - state.getClassFileVersion(), + state.getConfig().getClassFileVersion(), ACC_FINAL | ACC_SUPER | visibilityFlag | getSyntheticAccessFlagForLambdaClass(classDescriptor), asmType.getInternalName(), sw.makeJavaGenericSignature(), diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/CodeFragmentCodegen.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/CodeFragmentCodegen.kt index 8fd3e239b3c..a5b8410bfae 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/CodeFragmentCodegen.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/CodeFragmentCodegen.kt @@ -53,7 +53,7 @@ class CodeFragmentCodegen private constructor( override fun generateDeclaration() { v.defineClass( codeFragment, - state.classFileVersion, + state.config.classFileVersion, ACC_PUBLIC or ACC_SUPER, info.classType.internalName, null, diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/DescriptorAsmUtil.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/DescriptorAsmUtil.java index e007b177897..0d3f5017037 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/DescriptorAsmUtil.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/DescriptorAsmUtil.java @@ -676,7 +676,7 @@ public class DescriptorAsmUtil { @NotNull FunctionDescriptor descriptor, @NotNull FrameMap frameMap ) { - if (state.isParamAssertionsDisabled()) return; + if (state.getConfig().isParamAssertionsDisabled()) return; // currently when resuming a suspend function we pass default values instead of real arguments (i.e. nulls for references) if (descriptor.isSuspend()) return; @@ -688,7 +688,7 @@ public class DescriptorAsmUtil { // Such functions can be invoked in operator conventions desugaring, // which is currently done on ad hoc basis in ExpressionCodegen. - if (state.isReceiverAssertionsDisabled()) return; + if (state.getConfig().isReceiverAssertionsDisabled()) return; if (descriptor.isOperator()) { ReceiverParameterDescriptor receiverParameter = descriptor.getExtensionReceiverParameter(); if (receiverParameter != null) { @@ -737,7 +737,7 @@ public class DescriptorAsmUtil { } value.put(asmType, v); v.visitLdcInsn(name); - String methodName = state.getUnifiedNullChecks() ? "checkNotNullParameter" : "checkParameterIsNotNull"; + String methodName = state.getConfig().getUnifiedNullChecks() ? "checkNotNullParameter" : "checkParameterIsNotNull"; v.invokestatic(IntrinsicMethods.INTRINSICS_CLASS_NAME, methodName, "(Ljava/lang/Object;Ljava/lang/String;)V", false); } } @@ -748,7 +748,7 @@ public class DescriptorAsmUtil { @NotNull StackValue stackValue, @Nullable RuntimeAssertionInfo runtimeAssertionInfo ) { - if (state.isCallAssertionsDisabled()) return stackValue; + if (state.getConfig().isCallAssertionsDisabled()) return stackValue; if (runtimeAssertionInfo == null || !runtimeAssertionInfo.getNeedNotNullAssertion()) return stackValue; return new StackValue(stackValue.type, stackValue.kotlinType) { @@ -760,7 +760,8 @@ public class DescriptorAsmUtil { if (innerType.getSort() == Type.OBJECT || innerType.getSort() == Type.ARRAY) { v.dup(); v.visitLdcInsn(runtimeAssertionInfo.getMessage()); - String methodName = state.getUnifiedNullChecks() ? "checkNotNullExpressionValue" : "checkExpressionValueIsNotNull"; + String methodName = + state.getConfig().getUnifiedNullChecks() ? "checkNotNullExpressionValue" : "checkExpressionValueIsNotNull"; v.invokestatic(IntrinsicMethods.INTRINSICS_CLASS_NAME, methodName, "(Ljava/lang/Object;Ljava/lang/String;)V", false); } StackValue.coerce(innerType, innerKotlinType, type, kotlinType, v); diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java index f6263127ee0..22cf95ae393 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java @@ -13,7 +13,6 @@ import com.intellij.psi.tree.IElementType; import com.intellij.util.ArrayUtil; import com.intellij.util.Function; import com.intellij.util.containers.Stack; -import kotlin.Pair; import kotlin.Unit; import kotlin.collections.CollectionsKt; import kotlin.text.StringsKt; @@ -38,7 +37,6 @@ import org.jetbrains.kotlin.codegen.range.RangeValue; import org.jetbrains.kotlin.codegen.range.RangeValuesKt; import org.jetbrains.kotlin.codegen.range.forLoop.ForLoopGenerator; import org.jetbrains.kotlin.codegen.signature.BothSignatureWriter; -import org.jetbrains.kotlin.codegen.signature.JvmSignatureWriter; import org.jetbrains.kotlin.codegen.state.GenerationState; import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper; import org.jetbrains.kotlin.codegen.when.SwitchCodegen; @@ -62,14 +60,9 @@ import org.jetbrains.kotlin.name.Name; import org.jetbrains.kotlin.psi.*; import org.jetbrains.kotlin.psi.psiUtil.PsiUtilsKt; import org.jetbrains.kotlin.resolve.*; -import org.jetbrains.kotlin.resolve.calls.util.CallResolverUtilKt; -import org.jetbrains.kotlin.resolve.calls.util.CallUtilKt; import org.jetbrains.kotlin.resolve.calls.inference.CapturedTypeConstructorKt; import org.jetbrains.kotlin.resolve.calls.model.*; -import org.jetbrains.kotlin.resolve.calls.util.CallMaker; -import org.jetbrains.kotlin.resolve.calls.util.FakeCallableDescriptorForObject; -import org.jetbrains.kotlin.resolve.calls.util.FakeCallableDescriptorForTypeAliasObject; -import org.jetbrains.kotlin.resolve.calls.util.UnderscoreUtilKt; +import org.jetbrains.kotlin.resolve.calls.util.*; import org.jetbrains.kotlin.resolve.checkers.PrimitiveNumericComparisonInfo; import org.jetbrains.kotlin.resolve.constants.*; import org.jetbrains.kotlin.resolve.constants.evaluate.ConstantExpressionEvaluatorKt; @@ -857,12 +850,12 @@ public class ExpressionCodegen extends KtVisitor impleme @Nullable public ConstantValue getCompileTimeConstant(@NotNull KtExpression expression) { - return getCompileTimeConstant(expression, bindingContext, state.getShouldInlineConstVals()); + return getCompileTimeConstant(expression, bindingContext, state.getConfig().getShouldInlineConstVals()); } @Nullable public ConstantValue getPrimitiveOrStringCompileTimeConstant(@NotNull KtExpression expression) { - return getPrimitiveOrStringCompileTimeConstant(expression, bindingContext, state.getShouldInlineConstVals()); + return getPrimitiveOrStringCompileTimeConstant(expression, bindingContext, state.getConfig().getShouldInlineConstVals()); } @Nullable @@ -1686,7 +1679,7 @@ public class ExpressionCodegen extends KtVisitor impleme CallableMemberDescriptor descriptor = getContext().getContextDescriptor(); NonLocalReturnInfo nonLocalReturn = getNonLocalReturnInfo(descriptor, expression); boolean isNonLocalReturn = nonLocalReturn != null; - if (isNonLocalReturn && state.isInlineDisabled()) { + if (isNonLocalReturn && state.getConfig().isInlineDisabled()) { state.getDiagnostics().report(Errors.NON_LOCAL_RETURN_IN_DISABLED_INLINE.on(expression)); genThrow(v, "java/lang/UnsupportedOperationException", "Non-local returns are not allowed with inlining disabled"); @@ -2309,9 +2302,9 @@ public class ExpressionCodegen extends KtVisitor impleme PropertyDescriptor originalPropertyDescriptor = DescriptorUtils.unwrapFakeOverride(propertyDescriptor); boolean directAccessToGetter = - couldUseDirectAccessToProperty(propertyDescriptor, true, isDelegatedProperty, context, state.getShouldInlineConstVals()); + couldUseDirectAccessToProperty(propertyDescriptor, true, isDelegatedProperty, context, state.getConfig().getShouldInlineConstVals()); boolean directAccessToSetter = - couldUseDirectAccessToProperty(propertyDescriptor, false, isDelegatedProperty, context, state.getShouldInlineConstVals()); + couldUseDirectAccessToProperty(propertyDescriptor, false, isDelegatedProperty, context, state.getConfig().getShouldInlineConstVals()); if (fieldAccessorKind == AccessorKind.LATEINIT_INTRINSIC) { skipPropertyAccessors = @@ -2707,8 +2700,8 @@ public class ExpressionCodegen extends KtVisitor impleme @NotNull CallGenerator callGenerator, @NotNull ArgumentGenerator argumentGenerator ) { - if (AssertCodegenUtilKt.isAssertCall(resolvedCall) && !state.getAssertionsMode().equals(JVMAssertionsMode.LEGACY)) { - AssertCodegenUtilKt.generateAssert(state.getAssertionsMode(), resolvedCall, this, parentCodegen); + if (AssertCodegenUtilKt.isAssertCall(resolvedCall) && !state.getConfig().getAssertionsMode().equals(JVMAssertionsMode.LEGACY)) { + AssertCodegenUtilKt.generateAssert(state.getConfig().getAssertionsMode(), resolvedCall, this, parentCodegen); return; } @@ -2778,7 +2771,7 @@ public class ExpressionCodegen extends KtVisitor impleme KotlinType returnType = resolvedCall.getResultingDescriptor().getReturnType(); if (returnType != null && KotlinBuiltIns.isNothing(returnType)) { - if (state.getUseKotlinNothingValueException()) { + if (state.getConfig().getUseKotlinNothingValueException()) { v.anew(Type.getObjectType("kotlin/KotlinNothingValueException")); v.dup(); v.invokespecial("kotlin/KotlinNothingValueException", "", "()V", false); @@ -2881,7 +2874,7 @@ public class ExpressionCodegen extends KtVisitor impleme // We should inline callable containing reified type parameters even if inline is disabled // because they may contain something to reify and straight call will probably fail at runtime - boolean shouldInline = isInline && (!state.isInlineDisabled() || InlineUtil.containsReifiedTypeParameters(descriptor)); + boolean shouldInline = isInline && (!state.getConfig().isInlineDisabled() || InlineUtil.containsReifiedTypeParameters(descriptor)); if (!shouldInline) return defaultCallGenerator; FunctionDescriptor original = @@ -2994,7 +2987,7 @@ public class ExpressionCodegen extends KtVisitor impleme else if (receiverValue instanceof ExpressionReceiver) { ExpressionReceiver expressionReceiver = (ExpressionReceiver) receiverValue; StackValue stackValue = gen(expressionReceiver.getExpression()); - if (!state.isReceiverAssertionsDisabled()) { + if (!state.getConfig().isReceiverAssertionsDisabled()) { RuntimeAssertionInfo runtimeAssertionInfo = bindingContext.get(JvmBindingContextSlices.RECEIVER_RUNTIME_ASSERTION_INFO, expressionReceiver); stackValue = genNotNullAssertions(state, stackValue, runtimeAssertionInfo); @@ -4402,7 +4395,7 @@ public class ExpressionCodegen extends KtVisitor impleme return StackValue.operation(base.type, base.kotlinType, v -> { base.put(base.type, base.kotlinType, v); v.dup(); - if (state.getUnifiedNullChecks()) { + if (state.getConfig().getUnifiedNullChecks()) { v.invokestatic(IntrinsicMethods.INTRINSICS_CLASS_NAME, "checkNotNull", "(Ljava/lang/Object;)V", false); } else { Label ok = new Label(); @@ -5162,7 +5155,7 @@ The "returned" value of try expression with no finally is either the last expres } CodegenUtilKt.generateAsCast( - v, rightKotlinType, boxedRightType, safeAs, state.getUnifiedNullChecks() + v, rightKotlinType, boxedRightType, safeAs, state.getConfig().getUnifiedNullChecks() ); return Unit.INSTANCE; diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionsFromAnyGeneratorImpl.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionsFromAnyGeneratorImpl.java index a8a9d450e7d..3967ccb6694 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionsFromAnyGeneratorImpl.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionsFromAnyGeneratorImpl.java @@ -203,7 +203,7 @@ public class FunctionsFromAnyGeneratorImpl extends FunctionsFromAnyGenerator { iv.ifnull(ifNull); } - genHashCode(mv, iv, asmType, generationState.getTarget()); + genHashCode(mv, iv, asmType, generationState.getConfig().getTarget()); if (ifNull != null) { Label end = new Label(); diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/ImplementationBodyCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/ImplementationBodyCodegen.java index 23404e326fd..296a136e8b6 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/ImplementationBodyCodegen.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/ImplementationBodyCodegen.java @@ -232,7 +232,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { v.defineClass( myClass.getPsiOrParent(), - state.getClassFileVersion(), + state.getConfig().getClassFileVersion(), access, signature.getName(), signature.getJavaGenericSignature(), @@ -538,7 +538,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { ) { iv.load(index, classAsmType); if (couldUseDirectAccessToProperty(propertyDescriptor, /* forGetter = */ true, - /* isDelegated = */ false, context, state.getShouldInlineConstVals())) { + /* isDelegated = */ false, context, state.getConfig().getShouldInlineConstVals())) { KotlinType kotlinType = propertyDescriptor.getType(); Type type = state.getTypeMapper().mapType(kotlinType); String fieldName = ((FieldOwnerContext) context.getParentContext()).getFieldName(propertyDescriptor, false); diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/InterfaceImplBodyCodegen.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/InterfaceImplBodyCodegen.kt index 461562177ea..dc7abfd0e38 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/InterfaceImplBodyCodegen.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/InterfaceImplBodyCodegen.kt @@ -47,9 +47,9 @@ class InterfaceImplBodyCodegen( val codegenFlags = ACC_PUBLIC or ACC_FINAL or ACC_SUPER val flags = if (state.classBuilderMode == ClassBuilderMode.LIGHT_CLASSES) codegenFlags or ACC_STATIC else codegenFlags v.defineClass( - myClass.psiOrParent, state.classFileVersion, flags, - defaultImplType.internalName, - null, "java/lang/Object", ArrayUtil.EMPTY_STRING_ARRAY + myClass.psiOrParent, state.config.classFileVersion, flags, + defaultImplType.internalName, + null, "java/lang/Object", ArrayUtil.EMPTY_STRING_ARRAY ) v.visitSource(myClass.containingKtFile.name, null) } diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/MemberCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/MemberCodegen.java index 611580ee07e..b02f5667bbc 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/MemberCodegen.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/MemberCodegen.java @@ -191,7 +191,7 @@ public abstract class MemberCodegen initializerValue = - initializer != null ? ExpressionCodegen.getCompileTimeConstant(initializer, bindingContext, state.getShouldInlineConstVals()) : null; + initializer != null + ? ExpressionCodegen.getCompileTimeConstant(initializer, bindingContext, state.getConfig().getShouldInlineConstVals()) + : null; // we must write constant values for fields in light classes, // because Java's completion for annotation arguments uses this information if (initializerValue == null) return state.getClassBuilderMode().generateBodies; @@ -692,7 +694,7 @@ public abstract class MemberCodegen superCtorArgTypes = new ArrayList<>(); - if (state.getGenerateOptimizedCallableReferenceSuperClasses()) { + if (state.getConfig().getGenerateOptimizedCallableReferenceSuperClasses()) { CallableReferenceUtilKt.generateCallableReferenceDeclarationContainerClass(iv, property, state); superCtorArgTypes.add(JAVA_CLASS_TYPE); } else { @@ -706,7 +708,7 @@ public abstract class MemberCodegen { } } - v.defineClass(element, state.getClassFileVersion(), + v.defineClass(element, state.getConfig().getClassFileVersion(), ACC_PUBLIC | ACC_FINAL | ACC_SUPER | (isSynthetic ? ACC_SYNTHETIC : 0), packagePartType.getInternalName(), null, diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/PropertyCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/PropertyCodegen.java index d637060398b..a5e30870c43 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/PropertyCodegen.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/PropertyCodegen.java @@ -299,7 +299,7 @@ public class PropertyCodegen { KtExpression defaultValue = loadAnnotationArgumentDefaultValue(parameter, descriptor, expectedAnnotationConstructor); if (defaultValue != null) { ConstantValue constant = ExpressionCodegen.getCompileTimeConstant( - defaultValue, bindingContext, true, state.getShouldInlineConstVals()); + defaultValue, bindingContext, true, state.getConfig().getShouldInlineConstVals()); assert !state.getClassBuilderMode().generateBodies || constant != null : "Default value for annotation parameter should be compile time value: " + defaultValue.getText(); if (constant != null) { diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/PropertyReferenceCodegen.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/PropertyReferenceCodegen.kt index 28b94c2973a..93d0b4967ff 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/PropertyReferenceCodegen.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/PropertyReferenceCodegen.kt @@ -91,7 +91,7 @@ class PropertyReferenceCodegen( override fun generateDeclaration() { v.defineClass( element, - state.classFileVersion, + state.config.classFileVersion, ACC_FINAL or ACC_SUPER or DescriptorAsmUtil.getVisibilityAccessFlagForClass(classDescriptor) or DescriptorAsmUtil.getSyntheticAccessFlagForLambdaClass(classDescriptor), diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/SamWrapperCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/SamWrapperCodegen.java index 14947dea7a7..d6f33474679 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/SamWrapperCodegen.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/SamWrapperCodegen.java @@ -129,7 +129,7 @@ public class SamWrapperCodegen { : new String[] {samAsmType.getInternalName()}; cv.defineClass( file, - state.getClassFileVersion(), + state.getConfig().getClassFileVersion(), classFlags, asmType.getInternalName(), null, @@ -166,7 +166,7 @@ public class SamWrapperCodegen { generateDelegatesToDefaultImpl(asmType, classDescriptor, samType.getClassDescriptor(), functionCodegen, state); } - cv.done(state.getGenerateSmapCopyToAnnotation()); + cv.done(state.getConfig().getGenerateSmapCopyToAnnotation()); return asmType; } diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/ScriptCodegen.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/ScriptCodegen.kt index 44d88392e4b..92947040e52 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/ScriptCodegen.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/ScriptCodegen.kt @@ -43,7 +43,7 @@ class ScriptCodegen private constructor( override fun generateDeclaration() { v.defineClass( scriptDeclaration, - state.classFileVersion, + state.config.classFileVersion, ACC_PUBLIC or ACC_SUPER, classAsmType.internalName, null, diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/StackValue.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/StackValue.java index 623e3f6e993..f040372ee78 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/StackValue.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/StackValue.java @@ -1806,7 +1806,7 @@ public abstract class StackValue { return inlineConstant(type, kotlinType, v); } - if (descriptor.isConst() && codegen.getState().getShouldInlineConstVals()) { + if (descriptor.isConst() && codegen.getState().getConfig().getShouldInlineConstVals()) { return inlineConstant(type, kotlinType, v); } diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/StringConcatGenerator.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/StringConcatGenerator.kt index 98b4e7d931c..0e54cc76cd1 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/StringConcatGenerator.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/StringConcatGenerator.kt @@ -17,7 +17,6 @@ import org.jetbrains.org.objectweb.asm.Handle import org.jetbrains.org.objectweb.asm.Opcodes import org.jetbrains.org.objectweb.asm.Type import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter -import java.lang.StringBuilder class StringConcatGenerator(val mode: JvmStringConcat, val mv: InstructionAdapter) { @@ -236,7 +235,6 @@ class StringConcatGenerator(val mode: JvmStringConcat, val mv: InstructionAdapte } fun create(state: GenerationState, mv: InstructionAdapter) = - StringConcatGenerator(state.runtimeStringConcat, mv) - + StringConcatGenerator(state.config.runtimeStringConcat, mv) } } diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/codegenUtil.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/codegenUtil.kt index f5e5aec732c..1b053ea3ba7 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/codegenUtil.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/codegenUtil.kt @@ -593,7 +593,7 @@ private fun generateLambdaForRunSuspend( ) lambdaBuilder.defineClass( - originElement, state.classFileVersion, + originElement, state.config.classFileVersion, ACC_FINAL or ACC_SUPER or ACC_SYNTHETIC, internalName, null, AsmTypes.LAMBDA.internalName, @@ -676,7 +676,7 @@ private fun generateLambdaForRunSuspend( writeSyntheticClassMetadata(lambdaBuilder, state, false) - lambdaBuilder.done(state.generateSmapCopyToAnnotation) + lambdaBuilder.done(state.config.generateSmapCopyToAnnotation) return lambdaBuilder.thisName } diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/generateJava8ParameterNames.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/generateJava8ParameterNames.kt index 861f79020b8..e5c420a2fee 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/generateJava8ParameterNames.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/generateJava8ParameterNames.kt @@ -30,7 +30,7 @@ fun generateParameterNames( state: GenerationState, isSynthetic: Boolean ) { - if (!state.generateParametersMetadata || isSynthetic) { + if (!state.config.generateParametersMetadata || isSynthetic) { return } diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/AnonymousObjectTransformer.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/AnonymousObjectTransformer.kt index 6e13daf533d..beda6b9c2a5 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/AnonymousObjectTransformer.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/AnonymousObjectTransformer.kt @@ -59,7 +59,9 @@ class AnonymousObjectTransformer( createClassReader().accept(object : ClassVisitor(Opcodes.API_VERSION, classBuilder.visitor) { override fun visit(version: Int, access: Int, name: String, signature: String?, superName: String, interfaces: Array) { - classBuilder.defineClass(null, maxOf(version, state.classFileVersion), access, name, signature, superName, interfaces) + classBuilder.defineClass( + null, maxOf(version, state.config.classFileVersion), access, name, signature, superName, interfaces + ) if (superName.isCoroutineSuperClass()) { inliningContext.isContinuation = true } @@ -229,7 +231,7 @@ class AnonymousObjectTransformer( if (continuationClassName == transformationInfo.oldClassName) { coroutineTransformer.registerClassBuilder(continuationClassName) } else { - classBuilder.done(state.generateSmapCopyToAnnotation) + classBuilder.done(state.config.generateSmapCopyToAnnotation) } return transformationResult diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/MethodInliner.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/MethodInliner.kt index 263d1bc69b8..27010a9a67e 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/MethodInliner.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/MethodInliner.kt @@ -206,7 +206,7 @@ class MethodInliner( } for (classBuilder in childInliningContext.continuationBuilders.values) { - classBuilder.done(inliningContext.state.generateSmapCopyToAnnotation) + classBuilder.done(inliningContext.state.config.generateSmapCopyToAnnotation) } } else { result.addNotChangedClass(oldClassName) diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/ObjectTransformer.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/ObjectTransformer.kt index 3bc091174e3..b8e5faedf77 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/ObjectTransformer.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/ObjectTransformer.kt @@ -65,7 +65,9 @@ class WhenMappingTransformer( val fieldNode = transformationInfo.fieldNode classReader.accept(object : ClassVisitor(Opcodes.API_VERSION, classBuilder.visitor) { override fun visit(version: Int, access: Int, name: String, signature: String?, superName: String, interfaces: Array) { - classBuilder.defineClass(null, maxOf(version, state.classFileVersion), access, name, signature, superName, interfaces) + classBuilder.defineClass( + null, maxOf(version, state.config.classFileVersion), access, name, signature, superName, interfaces + ) } override fun visitField(access: Int, name: String, desc: String, signature: String?, value: Any?): FieldVisitor? { @@ -104,7 +106,7 @@ class WhenMappingTransformer( transformedClinit.signature, transformedClinit.exceptions.toTypedArray() ) transformedClinit.accept(result) - classBuilder.done(state.generateSmapCopyToAnnotation) + classBuilder.done(state.config.generateSmapCopyToAnnotation) return transformationResult } diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/PsiInlineCodegen.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/PsiInlineCodegen.kt index 239388c9780..5936df6a5e2 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/PsiInlineCodegen.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/PsiInlineCodegen.kt @@ -44,7 +44,7 @@ class PsiInlineCodegen( codegen, state, signature, typeParameterMappings, sourceCompiler, ReifiedTypeInliner( typeParameterMappings, PsiInlineIntrinsicsSupport(state, reportErrorsOn), codegen.typeSystem, - state.languageVersionSettings, state.unifiedNullChecks + state.languageVersionSettings, state.config.unifiedNullChecks ), ), CallGenerator { override fun generateAssertField() = diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/PsiInlineIntrinsicsSupport.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/PsiInlineIntrinsicsSupport.kt index 73a16974053..859fcdf06d4 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/PsiInlineIntrinsicsSupport.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/PsiInlineIntrinsicsSupport.kt @@ -46,7 +46,7 @@ class PsiInlineIntrinsicsSupport( } private fun generateFunctionReference(v: InstructionAdapter, descriptor: FunctionDescriptor) { - check(state.generateOptimizedCallableReferenceSuperClasses) { + check(state.config.generateOptimizedCallableReferenceSuperClasses) { "typeOf() of a non-reified type parameter is only allowed if optimized callable references are enabled.\n" + "Please make sure API version is set to 1.4, and -Xno-optimized-callable-references is NOT used.\n" + "Container: $descriptor" diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/SamWrapperTransformer.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/SamWrapperTransformer.kt index 298fdbea8f6..edd61a59474 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/SamWrapperTransformer.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/SamWrapperTransformer.kt @@ -61,11 +61,13 @@ class SamWrapperTransformer(transformationInfo: SamWrapperTransformationInfo, pr classReader.accept(object : ClassVisitor(Opcodes.API_VERSION, classBuilder.visitor) { override fun visit(version: Int, access: Int, name: String, signature: String?, superName: String, interfaces: Array) { - classBuilder.defineClass(null, maxOf(version, state.classFileVersion), access, name, signature, superName, interfaces) + classBuilder.defineClass( + null, maxOf(version, state.config.classFileVersion), access, name, signature, superName, interfaces + ) } }, ClassReader.SKIP_FRAMES) - classBuilder.done(inliningContext.state.generateSmapCopyToAnnotation) + classBuilder.done(inliningContext.state.config.generateSmapCopyToAnnotation) return transformationResult } diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/coroutines/CoroutineTransformer.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/coroutines/CoroutineTransformer.kt index d36a2719e05..458bdbcb233 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/coroutines/CoroutineTransformer.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/coroutines/CoroutineTransformer.kt @@ -142,7 +142,7 @@ class CoroutineTransformer( } fun replaceFakesWithReals(node: MethodNode) { - findFakeContinuationConstructorClassName(node)?.let(::unregisterClassBuilder)?.done(state.generateSmapCopyToAnnotation) + findFakeContinuationConstructorClassName(node)?.let(::unregisterClassBuilder)?.done(state.config.generateSmapCopyToAnnotation) replaceFakeContinuationsWithRealOnes( node, if (!inliningContext.isContinuation) getLastParameterIndex(node.desc, node.access) else 0 ) diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/typeOf.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/typeOf.kt index 1643b615f42..1db86d45b02 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/typeOf.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/typeOf.kt @@ -84,7 +84,7 @@ private fun TypeSystemCommonBackendContext.generateTypeO intrinsicsSupport.reportSuspendTypeUnsupported() } - if (intrinsicsSupport.state.stableTypeOf) { + if (intrinsicsSupport.state.config.stableTypeOf) { if (intrinsicsSupport.isMutableCollectionType(type)) { v.invokestatic(REFLECTION, "mutableCollectionType", Type.getMethodDescriptor(K_TYPE, K_TYPE), false) } else if (type.typeConstructor().isNothingConstructor()) { diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/MethodVerifier.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/MethodVerifier.kt index 39f776125c1..2a0cbeacca3 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/MethodVerifier.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/MethodVerifier.kt @@ -23,7 +23,7 @@ import org.jetbrains.org.objectweb.asm.tree.analysis.BasicVerifier class MethodVerifier(private val checkPoint: String, private val generationState: GenerationState) : MethodTransformer() { override fun transform(internalClassName: String, methodNode: MethodNode) { - if (!generationState.shouldValidateBytecode) return + if (!generationState.config.shouldValidateBytecode) return try { analyze(internalClassName, methodNode, BasicVerifier()) } catch (e: Throwable) { diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/OptimizationMethodVisitor.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/OptimizationMethodVisitor.kt index 025f05c9af9..5da9b3a8db3 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/OptimizationMethodVisitor.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/OptimizationMethodVisitor.kt @@ -69,7 +69,7 @@ class OptimizationMethodVisitor( normalizationMethodTransformer.transform("fake", methodNode) UninitializedStoresProcessor(methodNode).run() - if (!mandatoryTransformationsOnly && canBeOptimized(methodNode) && !generationState.disableOptimization) { + if (!mandatoryTransformationsOnly && canBeOptimized(methodNode) && !generationState.config.disableOptimization) { optimizationTransformer.transform("fake", methodNode) } diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/serialization/JvmSerializerExtension.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/serialization/JvmSerializerExtension.kt index cd07a3d9cde..e902135fd4d 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/serialization/JvmSerializerExtension.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/serialization/JvmSerializerExtension.kt @@ -49,17 +49,17 @@ class JvmSerializerExtension @JvmOverloads constructor( private val globalBindings = state.globalSerializationBindings private val codegenBinding = state.bindingContext override val stringTable = JvmCodegenStringTable(typeMapper) - private val useTypeTable = state.useTypeTableInSerializer + private val useTypeTable = state.config.useTypeTableInSerializer private val moduleName = state.moduleName private val classBuilderMode = state.classBuilderMode private val languageVersionSettings = state.languageVersionSettings - private val isParamAssertionsDisabled = state.isParamAssertionsDisabled - private val unifiedNullChecks = state.unifiedNullChecks - private val functionsWithInlineClassReturnTypesMangled = state.functionsWithInlineClassReturnTypesMangled - override val metadataVersion = state.metadataVersion + private val isParamAssertionsDisabled = state.config.isParamAssertionsDisabled + private val unifiedNullChecks = state.config.unifiedNullChecks + private val functionsWithInlineClassReturnTypesMangled = state.config.functionsWithInlineClassReturnTypesMangled + override val metadataVersion = state.config.metadataVersion private val jvmDefaultMode = state.jvmDefaultMode private val approximator = state.typeApproximator - private val useOldManglingScheme = state.useOldManglingSchemeForFunctionsWithInlineClassesInSignatures + private val useOldManglingScheme = state.config.useOldManglingSchemeForFunctionsWithInlineClassesInSignatures private val signatureSerializer = JvmSignatureSerializerImpl(stringTable) override fun shouldUseTypeTable(): Boolean = useTypeTable 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 f4cd6604198..41b9fd1de3e 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/GenerationState.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/GenerationState.kt @@ -52,7 +52,6 @@ import org.jetbrains.kotlin.serialization.deserialization.DeserializationConfigu import org.jetbrains.kotlin.storage.LockBasedStorageManager import org.jetbrains.kotlin.types.KotlinType import org.jetbrains.kotlin.types.TypeApproximator -import org.jetbrains.kotlin.utils.metadataVersion import org.jetbrains.org.objectweb.asm.Type import java.io.File @@ -179,7 +178,8 @@ class GenerationState private constructor( } } - val languageVersionSettings = configuration.languageVersionSettings + val config = JvmBackendConfig(configuration) + val languageVersionSettings = config.languageVersionSettings val inlineCache: InlineCache = InlineCache() @@ -219,7 +219,7 @@ class GenerationState private constructor( } } - val extraJvmDiagnosticsTrace: BindingTrace = + private val extraJvmDiagnosticsTrace: BindingTrace = DelegatingBindingTrace( originalFrontendBindingContext, "For extra diagnostics in ${this::class.java}", false, customSuppressCache = if (isIrBackend) OnDemandSuppressCache(originalFrontendBindingContext) else null, @@ -234,29 +234,6 @@ class GenerationState private constructor( extraJvmDiagnosticsTrace.bindingContext.diagnostics } - val useOldManglingSchemeForFunctionsWithInlineClassesInSignatures = - configuration.getBoolean(JVMConfigurationKeys.USE_OLD_INLINE_CLASSES_MANGLING_SCHEME) || - languageVersionSettings.languageVersion.run { major == 1 && minor < 4 } - - val target = configuration.get(JVMConfigurationKeys.JVM_TARGET) ?: JvmTarget.DEFAULT - val runtimeStringConcat = - if (target.majorVersion >= JvmTarget.JVM_9.majorVersion) - configuration.get(JVMConfigurationKeys.STRING_CONCAT) ?: JvmStringConcat.INDY_WITH_CONSTANTS - else JvmStringConcat.INLINE - - val samConversionsScheme: JvmClosureGenerationScheme = - configuration.get(JVMConfigurationKeys.SAM_CONVERSIONS) - ?: if (languageVersionSettings.supportsFeature(LanguageFeature.SamWrapperClassesAreSynthetic)) - JvmClosureGenerationScheme.INDY - else - JvmClosureGenerationScheme.CLASS - - val lambdasScheme: JvmClosureGenerationScheme = - configuration.get(JVMConfigurationKeys.LAMBDAS) - ?: if (languageVersionSettings.supportsFeature(LanguageFeature.LightweightLambdas)) - JvmClosureGenerationScheme.INDY - else JvmClosureGenerationScheme.CLASS - val moduleName: String = moduleName ?: JvmCodegenUtil.getModuleName(module) val classBuilderMode: ClassBuilderMode = builderFactory.classBuilderMode val bindingTrace: BindingTrace = DelegatingBindingTrace( @@ -270,27 +247,18 @@ class GenerationState private constructor( classBuilderMode, this.moduleName, languageVersionSettings, - useOldManglingSchemeForFunctionsWithInlineClassesInSignatures, - target, + config.useOldManglingSchemeForFunctionsWithInlineClassesInSignatures, + config.target, isIrBackend ) - val canReplaceStdlibRuntimeApiBehavior = languageVersionSettings.apiVersion <= ApiVersion.parse(KotlinVersion.CURRENT.toString())!! - val intrinsics: IntrinsicMethods = IntrinsicMethods(canReplaceStdlibRuntimeApiBehavior) - val generateOptimizedCallableReferenceSuperClasses = - languageVersionSettings.apiVersion >= ApiVersion.KOTLIN_1_4 && - !configuration.getBoolean(JVMConfigurationKeys.NO_OPTIMIZED_CALLABLE_REFERENCES) - val useKotlinNothingValueException = - languageVersionSettings.apiVersion >= ApiVersion.KOTLIN_1_4 && - !configuration.getBoolean(JVMConfigurationKeys.NO_KOTLIN_NOTHING_VALUE_EXCEPTION) - - // In 1.6, `typeOf` became stable and started to rely on a few internal stdlib functions which were missing before 1.6. - val stableTypeOf = languageVersionSettings.apiVersion >= ApiVersion.KOTLIN_1_6 + val intrinsics: IntrinsicMethods = + IntrinsicMethods(languageVersionSettings.apiVersion <= ApiVersion.parse(KotlinVersion.CURRENT.toString())!!) val samWrapperClasses: SamWrapperClasses = SamWrapperClasses(this) val globalInlineContext: GlobalInlineContext = GlobalInlineContext(diagnostics) val mappingsClassesForWhenByEnum: MappingsClassesForWhenByEnum = MappingsClassesForWhenByEnum(this) val jvmRuntimeTypes: JvmRuntimeTypes = JvmRuntimeTypes( - module, languageVersionSettings, generateOptimizedCallableReferenceSuperClasses + module, languageVersionSettings, config.generateOptimizedCallableReferenceSuperClasses ) val factory: ClassFileFactory private var duplicateSignatureFactory: BuilderFactoryForDuplicateSignatureDiagnostics? = null @@ -307,53 +275,10 @@ class GenerationState private constructor( var resultType: KotlinType? = null } - val isCallAssertionsDisabled: Boolean = configuration.getBoolean(JVMConfigurationKeys.DISABLE_CALL_ASSERTIONS) - val isReceiverAssertionsDisabled: Boolean = - configuration.getBoolean(JVMConfigurationKeys.DISABLE_RECEIVER_ASSERTIONS) || - !languageVersionSettings.supportsFeature(LanguageFeature.NullabilityAssertionOnExtensionReceiver) - val isParamAssertionsDisabled: Boolean = configuration.getBoolean(JVMConfigurationKeys.DISABLE_PARAM_ASSERTIONS) - val assertionsMode: JVMAssertionsMode = configuration.get(JVMConfigurationKeys.ASSERTIONS_MODE, JVMAssertionsMode.DEFAULT) - val isInlineDisabled: Boolean = configuration.getBoolean(CommonConfigurationKeys.DISABLE_INLINE) - val useTypeTableInSerializer: Boolean = configuration.getBoolean(JVMConfigurationKeys.USE_TYPE_TABLE) - val unifiedNullChecks: Boolean = - languageVersionSettings.apiVersion >= ApiVersion.KOTLIN_1_4 && - !configuration.getBoolean(JVMConfigurationKeys.NO_UNIFIED_NULL_CHECKS) - - val noSourceCodeInNotNullAssertionExceptions: Boolean = - (languageVersionSettings.supportsFeature(LanguageFeature.NoSourceCodeInNotNullAssertionExceptions) - // This check is needed because we generate calls to `Intrinsics.checkNotNull` which is only available since 1.4 - // (when unified null checks were introduced). - && unifiedNullChecks) - // Never generate source code in assertion exceptions in K2 to make behavior of FIR PSI & FIR light-tree equivalent - // (obtaining source code is not supported in light tree). - || languageVersionSettings.languageVersion.usesK2 - - val generateSmapCopyToAnnotation: Boolean = !configuration.getBoolean(JVMConfigurationKeys.NO_SOURCE_DEBUG_EXTENSION) - val functionsWithInlineClassReturnTypesMangled: Boolean = - languageVersionSettings.supportsFeature(LanguageFeature.MangleClassMembersReturningInlineClasses) - val shouldValidateIr = configuration.getBoolean(JVMConfigurationKeys.VALIDATE_IR) - val shouldValidateBytecode = configuration.getBoolean(JVMConfigurationKeys.VALIDATE_BYTECODE) - val rootContext: CodegenContext<*> = RootContext(this) - val classFileVersion: Int = run { - val minorVersion = if (configuration.getBoolean(JVMConfigurationKeys.ENABLE_JVM_PREVIEW)) 0xffff else 0 - (minorVersion shl 16) + target.majorVersion - } - - val generateParametersMetadata: Boolean = configuration.getBoolean(JVMConfigurationKeys.PARAMETERS_METADATA) - - val shouldInlineConstVals = languageVersionSettings.supportsFeature(LanguageFeature.InlineConstVals) - - val jvmDefaultMode = languageVersionSettings.getFlag(JvmAnalysisFlags.jvmDefaultMode) - - val disableOptimization = configuration.get(JVMConfigurationKeys.DISABLE_OPTIMIZATION, false) - - val metadataVersion = configuration.metadataVersion() - - val abiStability = configuration.get(JVMConfigurationKeys.ABI_STABILITY) - - val noNewJavaAnnotationTargets = configuration.getBoolean(JVMConfigurationKeys.NO_NEW_JAVA_ANNOTATION_TARGETS) + val jvmDefaultMode: JvmDefaultMode + get() = config.jvmDefaultMode val globalSerializationBindings = JvmSerializationBindings() var mapInlineClass: (ClassDescriptor) -> Type = { descriptor -> typeMapper.mapType(descriptor.defaultType) } @@ -372,8 +297,6 @@ class GenerationState private constructor( else null - val oldInnerClassesLogic = configuration.getBoolean(JVMConfigurationKeys.OLD_INNER_CLASSES_LOGIC) - init { this.interceptedBuilderFactory = builderFactory .wrapWith( @@ -391,7 +314,7 @@ class GenerationState private constructor( else BuilderFactoryForDuplicateSignatureDiagnostics( it, bindingContext, diagnostics, this.moduleName, languageVersionSettings, - useOldManglingSchemeForFunctionsWithInlineClassesInSignatures, + config.useOldManglingSchemeForFunctionsWithInlineClassesInSignatures, shouldGenerate = { origin -> !shouldOnlyCollectSignatures(origin) }, ).apply { duplicateSignatureFactory = this } }, diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/JvmBackendConfig.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/JvmBackendConfig.kt new file mode 100644 index 00000000000..c1f36042ee8 --- /dev/null +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/JvmBackendConfig.kt @@ -0,0 +1,103 @@ +/* + * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.codegen.state + +import org.jetbrains.kotlin.config.* +import org.jetbrains.kotlin.metadata.deserialization.BinaryVersion +import org.jetbrains.kotlin.utils.metadataVersion + +class JvmBackendConfig(configuration: CompilerConfiguration) { + val languageVersionSettings: LanguageVersionSettings = configuration.languageVersionSettings + + val target: JvmTarget = + configuration.get(JVMConfigurationKeys.JVM_TARGET) ?: JvmTarget.DEFAULT + + val useOldManglingSchemeForFunctionsWithInlineClassesInSignatures: Boolean = + configuration.getBoolean(JVMConfigurationKeys.USE_OLD_INLINE_CLASSES_MANGLING_SCHEME) || + languageVersionSettings.languageVersion.run { major == 1 && minor < 4 } + + val runtimeStringConcat: JvmStringConcat = + if (target.majorVersion >= JvmTarget.JVM_9.majorVersion) + configuration.get(JVMConfigurationKeys.STRING_CONCAT) ?: JvmStringConcat.INDY_WITH_CONSTANTS + else JvmStringConcat.INLINE + + val samConversionsScheme: JvmClosureGenerationScheme = + configuration.get(JVMConfigurationKeys.SAM_CONVERSIONS) + ?: if (languageVersionSettings.supportsFeature(LanguageFeature.SamWrapperClassesAreSynthetic)) + JvmClosureGenerationScheme.INDY + else + JvmClosureGenerationScheme.CLASS + + val lambdasScheme: JvmClosureGenerationScheme = + configuration.get(JVMConfigurationKeys.LAMBDAS) + ?: if (languageVersionSettings.supportsFeature(LanguageFeature.LightweightLambdas)) + JvmClosureGenerationScheme.INDY + else JvmClosureGenerationScheme.CLASS + + val useKotlinNothingValueException: Boolean = + languageVersionSettings.apiVersion >= ApiVersion.KOTLIN_1_4 && + !configuration.getBoolean(JVMConfigurationKeys.NO_KOTLIN_NOTHING_VALUE_EXCEPTION) + + // In 1.6, `typeOf` became stable and started to rely on a few internal stdlib functions which were missing before 1.6. + val stableTypeOf: Boolean = + languageVersionSettings.apiVersion >= ApiVersion.KOTLIN_1_6 + + val generateOptimizedCallableReferenceSuperClasses: Boolean = + languageVersionSettings.apiVersion >= ApiVersion.KOTLIN_1_4 && + !configuration.getBoolean(JVMConfigurationKeys.NO_OPTIMIZED_CALLABLE_REFERENCES) + + val isCallAssertionsDisabled: Boolean = configuration.getBoolean(JVMConfigurationKeys.DISABLE_CALL_ASSERTIONS) + val isReceiverAssertionsDisabled: Boolean = + configuration.getBoolean(JVMConfigurationKeys.DISABLE_RECEIVER_ASSERTIONS) || + !languageVersionSettings.supportsFeature(LanguageFeature.NullabilityAssertionOnExtensionReceiver) + val isParamAssertionsDisabled: Boolean = configuration.getBoolean(JVMConfigurationKeys.DISABLE_PARAM_ASSERTIONS) + + val assertionsMode: JVMAssertionsMode = configuration.get(JVMConfigurationKeys.ASSERTIONS_MODE, JVMAssertionsMode.DEFAULT) + val isInlineDisabled: Boolean = configuration.getBoolean(CommonConfigurationKeys.DISABLE_INLINE) + val useTypeTableInSerializer: Boolean = configuration.getBoolean(JVMConfigurationKeys.USE_TYPE_TABLE) + + val unifiedNullChecks: Boolean = + languageVersionSettings.apiVersion >= ApiVersion.KOTLIN_1_4 && + !configuration.getBoolean(JVMConfigurationKeys.NO_UNIFIED_NULL_CHECKS) + + val noSourceCodeInNotNullAssertionExceptions: Boolean = + (languageVersionSettings.supportsFeature(LanguageFeature.NoSourceCodeInNotNullAssertionExceptions) + // This check is needed because we generate calls to `Intrinsics.checkNotNull` which is only available since 1.4 + // (when unified null checks were introduced). + && unifiedNullChecks) + // Never generate source code in assertion exceptions in K2 to make behavior of FIR PSI & FIR light-tree equivalent + // (obtaining source code is not supported in light tree). + || languageVersionSettings.languageVersion.usesK2 + + val generateSmapCopyToAnnotation: Boolean = !configuration.getBoolean(JVMConfigurationKeys.NO_SOURCE_DEBUG_EXTENSION) + + val functionsWithInlineClassReturnTypesMangled: Boolean = + languageVersionSettings.supportsFeature(LanguageFeature.MangleClassMembersReturningInlineClasses) + + val shouldValidateIr: Boolean = configuration.getBoolean(JVMConfigurationKeys.VALIDATE_IR) + val shouldValidateBytecode: Boolean = configuration.getBoolean(JVMConfigurationKeys.VALIDATE_BYTECODE) + + val classFileVersion: Int = run { + val minorVersion = if (configuration.getBoolean(JVMConfigurationKeys.ENABLE_JVM_PREVIEW)) 0xffff else 0 + (minorVersion shl 16) + target.majorVersion + } + + val generateParametersMetadata: Boolean = configuration.getBoolean(JVMConfigurationKeys.PARAMETERS_METADATA) + + val shouldInlineConstVals: Boolean = languageVersionSettings.supportsFeature(LanguageFeature.InlineConstVals) + + val jvmDefaultMode: JvmDefaultMode = languageVersionSettings.getFlag(JvmAnalysisFlags.jvmDefaultMode) + + val disableOptimization: Boolean = configuration.getBoolean(JVMConfigurationKeys.DISABLE_OPTIMIZATION) + + val metadataVersion: BinaryVersion = configuration.metadataVersion() + + val abiStability: JvmAbiStability? = configuration.get(JVMConfigurationKeys.ABI_STABILITY) + + val noNewJavaAnnotationTargets: Boolean = configuration.getBoolean(JVMConfigurationKeys.NO_NEW_JAVA_ANNOTATION_TARGETS) + + val oldInnerClassesLogic: Boolean = configuration.getBoolean(JVMConfigurationKeys.OLD_INNER_CLASSES_LOGIC) +} diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/when/MappingClassesForWhenByEnumCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/when/MappingClassesForWhenByEnumCodegen.java index 94d25c6c40d..13bda66e5f5 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/when/MappingClassesForWhenByEnumCodegen.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/when/MappingClassesForWhenByEnumCodegen.java @@ -46,7 +46,7 @@ public class MappingClassesForWhenByEnumCodegen { ClassBuilder cb = state.getFactory().newVisitor(JvmDeclarationOrigin.NO_ORIGIN, mappingsClass, srcFile); cb.defineClass( srcFile, - state.getClassFileVersion(), + state.getConfig().getClassFileVersion(), ACC_PUBLIC | ACC_FINAL | ACC_SUPER | ACC_SYNTHETIC, mappingsClass.getInternalName(), null, @@ -60,7 +60,7 @@ public class MappingClassesForWhenByEnumCodegen { boolean publicAbi = mappings.stream().anyMatch(WhenByEnumsMapping::isPublicAbi); WriteAnnotationUtilKt.writeSyntheticClassMetadata(cb, state, publicAbi); - cb.done(state.getGenerateSmapCopyToAnnotation()); + cb.done(state.getConfig().getGenerateSmapCopyToAnnotation()); } private static void generateFields(@NotNull ClassBuilder cb, @NotNull List mappings) { diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/when/SwitchCodegenProvider.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/when/SwitchCodegenProvider.kt index 9d68865ac58..3c5d390d249 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/when/SwitchCodegenProvider.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/when/SwitchCodegenProvider.kt @@ -34,8 +34,8 @@ private constructor( private val shouldInlineConstVals: Boolean, private val codegen: ExpressionCodegen? ) { - constructor(state: GenerationState) : this(state.bindingContext, state.shouldInlineConstVals, null) - constructor(codegen: ExpressionCodegen) : this(codegen.bindingContext, codegen.state.shouldInlineConstVals, codegen) + constructor(state: GenerationState) : this(state.bindingContext, state.config.shouldInlineConstVals, null) + constructor(codegen: ExpressionCodegen) : this(codegen.bindingContext, codegen.state.config.shouldInlineConstVals, codegen) fun checkAllItemsAreConstantsSatisfying(expression: KtWhenExpression, predicate: Function1, Boolean>): Boolean = expression.entries.all { entry -> diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/writeAnnotationUtil.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/writeAnnotationUtil.kt index 351a6e6772d..a8635e784ea 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/writeAnnotationUtil.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/writeAnnotationUtil.kt @@ -32,8 +32,8 @@ fun writeKotlinMetadata( action: (AnnotationVisitor) -> Unit ) { val av = cb.newAnnotation(JvmAnnotationNames.METADATA_DESC, true) - av.visit(JvmAnnotationNames.METADATA_VERSION_FIELD_NAME, state.metadataVersion.toArray()) - if (!state.metadataVersion.isAtLeast(1, 5, 0)) { + av.visit(JvmAnnotationNames.METADATA_VERSION_FIELD_NAME, state.config.metadataVersion.toArray()) + if (!state.config.metadataVersion.isAtLeast(1, 5, 0)) { av.visit("bv", JvmBytecodeBinaryVersion.INSTANCE.toArray()) } av.visit(JvmAnnotationNames.KIND_FIELD_NAME, kind.id) diff --git a/compiler/fir/fir2ir/jvm-backend/src/org/jetbrains/kotlin/fir/backend/jvm/FirJvmSerializerExtension.kt b/compiler/fir/fir2ir/jvm-backend/src/org/jetbrains/kotlin/fir/backend/jvm/FirJvmSerializerExtension.kt index 47bb3884565..3ca7184bfd7 100644 --- a/compiler/fir/fir2ir/jvm-backend/src/org/jetbrains/kotlin/fir/backend/jvm/FirJvmSerializerExtension.kt +++ b/compiler/fir/fir2ir/jvm-backend/src/org/jetbrains/kotlin/fir/backend/jvm/FirJvmSerializerExtension.kt @@ -77,8 +77,8 @@ class FirJvmSerializerExtension( components: Fir2IrComponents ) : this( session, bindings, metadata, localDelegatedProperties, approximator, components.scopeSession, - state.globalSerializationBindings, state.useTypeTableInSerializer, state.moduleName, state.classBuilderMode, - state.isParamAssertionsDisabled, state.unifiedNullChecks, state.metadataVersion, state.jvmDefaultMode, + state.globalSerializationBindings, state.config.useTypeTableInSerializer, state.moduleName, state.classBuilderMode, + state.config.isParamAssertionsDisabled, state.config.unifiedNullChecks, state.config.metadataVersion, state.jvmDefaultMode, FirJvmElementAwareStringTable(typeMapper, components), ConstValueProviderImpl(components), components.annotationsFromPluginRegistrar.createMetadataAnnotationsProvider() ) diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/ClassCodegen.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/ClassCodegen.kt index b497d93146a..4c5cbdc7806 100644 --- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/ClassCodegen.kt +++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/ClassCodegen.kt @@ -86,7 +86,7 @@ class ClassCodegen private constructor( private val innerClasses = mutableSetOf() val typeMapper = - if (context.state.oldInnerClassesLogic) + if (context.config.oldInnerClassesLogic) context.defaultTypeMapper else object : IrTypeMapper(context) { override fun mapType(type: IrType, mode: TypeMappingMode, sw: JvmSignatureWriter?, materialized: Boolean): Type { @@ -118,7 +118,7 @@ class ClassCodegen private constructor( } defineClass( irClass.psiElement, - state.classFileVersion, + state.config.classFileVersion, irClass.getFlags(context.state.languageVersionSettings), signature.name, signature.javaGenericSignature, @@ -151,7 +151,7 @@ class ClassCodegen private constructor( // Generate PermittedSubclasses attribute for sealed class. if (state.languageVersionSettings.supportsFeature(LanguageFeature.JvmPermittedSubclassesAttributeForSealed) && irClass.modality == Modality.SEALED && - state.target >= JvmTarget.JVM_17 + state.config.target >= JvmTarget.JVM_17 ) { generatePermittedSubclasses() } @@ -213,7 +213,7 @@ class ClassCodegen private constructor( generateInnerAndOuterClasses() - visitor.done(state.generateSmapCopyToAnnotation) + visitor.done(state.config.generateSmapCopyToAnnotation) jvmSignatureClashDetector.reportErrors() } @@ -281,7 +281,7 @@ class ClassCodegen private constructor( val isMultifileClassOrPart = kind == KotlinClassHeader.Kind.MULTIFILE_CLASS || kind == KotlinClassHeader.Kind.MULTIFILE_CLASS_PART - var extraFlags = context.backendExtension.generateMetadataExtraFlags(state.abiStability) + var extraFlags = context.backendExtension.generateMetadataExtraFlags(state.config.abiStability) if (isMultifileClassOrPart && state.languageVersionSettings.getFlag(JvmAnalysisFlags.inheritMultifileParts)) { extraFlags = extraFlags or JvmAnnotationNames.METADATA_MULTIFILE_PARTS_INHERIT_FLAG } diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/ExpressionCodegen.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/ExpressionCodegen.kt index c27d1627469..9dd47d74d92 100644 --- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/ExpressionCodegen.kt +++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/ExpressionCodegen.kt @@ -279,7 +279,7 @@ class ExpressionCodegen( } private fun generateNonNullAssertions() { - if (state.isParamAssertionsDisabled) + if (state.config.isParamAssertionsDisabled) return if ((DescriptorVisibilities.isPrivate(irFunction.visibility) && !shouldGenerateNonNullAssertionsForPrivateFun(irFunction)) || @@ -339,7 +339,7 @@ class ExpressionCodegen( if (!expandedType.isNullable() && !isPrimitive(asmType)) { mv.load(findLocalIndex(param.symbol), asmType) mv.aconst(param.name.asString()) - val methodName = if (state.unifiedNullChecks) "checkNotNullParameter" else "checkParameterIsNotNull" + val methodName = if (state.config.unifiedNullChecks) "checkNotNullParameter" else "checkParameterIsNotNull" mv.invokestatic(JvmSymbols.INTRINSICS_CLASS_NAME, methodName, "(Ljava/lang/Object;Ljava/lang/String;)V", false) } } @@ -823,7 +823,7 @@ class ExpressionCodegen( override fun visitFieldAccess(expression: IrFieldAccessExpression, data: BlockInfo): PromisedValue { val callee = expression.symbol.owner - if (context.state.shouldInlineConstVals) { + if (context.config.shouldInlineConstVals) { // Const fields should only have reads, and those should have been transformed by ConstLowering. assert(callee.constantValue() == null) { "access of const val: ${expression.dump()}" } } @@ -983,7 +983,7 @@ class ExpressionCodegen( } private fun generateGlobalReturnFlagIfPossible(expression: IrExpression, label: String) { - if (state.isInlineDisabled) { + if (state.config.isInlineDisabled) { context.ktDiagnosticReporter.at(expression, irFunction).report(BackendErrors.NON_LOCAL_RETURN_IN_DISABLED_INLINE) genThrow(mv, "java/lang/UnsupportedOperationException", "Non-local returns are not allowed with inlining disabled") } else { @@ -1476,10 +1476,10 @@ class ExpressionCodegen( } override fun visitStringConcatenation(expression: IrStringConcatenation, data: BlockInfo): PromisedValue { - assert(context.state.runtimeStringConcat.isDynamic) { + assert(context.config.runtimeStringConcat.isDynamic) { "IrStringConcatenation expression should be presented only with dynamic concatenation: ${expression.dump()}" } - val generator = StringConcatGenerator(context.state.runtimeStringConcat, mv) + val generator = StringConcatGenerator(context.config.runtimeStringConcat, mv) expression.arguments.forEach { arg -> if (arg is IrConst<*>) { val type = when (arg.kind) { @@ -1580,7 +1580,7 @@ class ExpressionCodegen( IrInlineIntrinsicsSupport(classCodegen, element, irFunction.fileParent), context.typeSystem, state.languageVersionSettings, - state.unifiedNullChecks, + state.config.unifiedNullChecks, ) return IrInlineCodegen(this, state, callee, signature, mappings, sourceCompiler, reifiedTypeInliner) diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/FunctionCodegen.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/FunctionCodegen.kt index ce76bbaecc5..7629160f0c8 100644 --- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/FunctionCodegen.kt +++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/FunctionCodegen.kt @@ -70,7 +70,7 @@ class FunctionCodegen(private val irFunction: IrFunction, private val classCodeg ) val methodVisitor: MethodVisitor = wrapWithMaxLocalCalc(methodNode) - if (context.state.generateParametersMetadata && !isSynthetic) { + if (context.config.generateParametersMetadata && !isSynthetic) { generateParameterNames(irFunction, methodVisitor, context.state) } diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/IrInlineIntrinsicsSupport.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/IrInlineIntrinsicsSupport.kt index 0442bc6658d..ae340edf9b3 100644 --- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/IrInlineIntrinsicsSupport.kt +++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/IrInlineIntrinsicsSupport.kt @@ -58,7 +58,7 @@ class IrInlineIntrinsicsSupport( when (val parent = typeParameter.owner.parent) { is IrClass -> putClassInstance(v, parent.defaultType).also { AsmUtil.wrapJavaClassIntoKClass(v) } is IrSimpleFunction -> { - check(classCodegen.context.state.generateOptimizedCallableReferenceSuperClasses) { + check(classCodegen.context.config.generateOptimizedCallableReferenceSuperClasses) { "typeOf() of a non-reified type parameter is only allowed if optimized callable references are enabled.\n" + "Please make sure API version is set to 1.4, and -Xno-optimized-callable-references is NOT used.\n" + "Container: $parent" 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 6f0233017ba..9c38c15a786 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 @@ -33,7 +33,7 @@ object HashCode : IntrinsicMethod() { val receiverJvmType = typeMapper.mapType(receiverIrType) val receiverValue = receiver.accept(this, data).materialized() val receiverType = receiverValue.type - val target = context.state.target + val target = context.config.target when { irFunction.origin == JvmLoweredDeclarationOrigin.INLINE_CLASS_GENERATED_IMPL_METHOD || irFunction.origin == JvmLoweredDeclarationOrigin.MULTI_FIELD_VALUE_CLASS_GENERATED_IMPL_METHOD || diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrCheckNotNull.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrCheckNotNull.kt index 1d2b02f74aa..881fb7044d0 100644 --- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrCheckNotNull.kt +++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrCheckNotNull.kt @@ -31,7 +31,7 @@ object IrCheckNotNull : IntrinsicMethod() { private fun ExpressionCodegen.checkTopValueForNull() { mv.dup() - if (state.unifiedNullChecks) { + if (state.config.unifiedNullChecks) { mv.invokestatic(IntrinsicMethods.INTRINSICS_CLASS_NAME, "checkNotNull", "(Ljava/lang/Object;)V", false) } else { val ifNonNullLabel = Label() diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/ThrowKotlinNothingValueException.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/ThrowKotlinNothingValueException.kt index ecbdde207b3..74b7496666e 100644 --- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/ThrowKotlinNothingValueException.kt +++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/ThrowKotlinNothingValueException.kt @@ -17,7 +17,7 @@ object ThrowKotlinNothingValueException : IntrinsicMethod() { classCodegen: ClassCodegen ): IntrinsicFunction = IntrinsicFunction.create(expression, signature, classCodegen) { mv -> - if (classCodegen.context.state.useKotlinNothingValueException) { + if (classCodegen.context.config.useKotlinNothingValueException) { mv.anew(Type.getObjectType("kotlin/KotlinNothingValueException")) mv.dup() mv.invokespecial("kotlin/KotlinNothingValueException", "", "()V", false) @@ -26,4 +26,4 @@ object ThrowKotlinNothingValueException : IntrinsicMethod() { } mv.athrow() } -} \ No newline at end of file +} diff --git a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/AdditionalClassAnnotationLowering.kt b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/AdditionalClassAnnotationLowering.kt index 9ab5da6f012..66616e71b93 100644 --- a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/AdditionalClassAnnotationLowering.kt +++ b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/AdditionalClassAnnotationLowering.kt @@ -38,7 +38,7 @@ internal val additionalClassAnnotationPhase = makeIrFilePhase( private class AdditionalClassAnnotationLowering(private val context: JvmBackendContext) : ClassLoweringPass { private val symbols = context.ir.symbols.javaAnnotations private val noNewJavaAnnotationTargets = - context.state.noNewJavaAnnotationTargets || !context.isCompilingAgainstJdk8OrLater + context.config.noNewJavaAnnotationTargets || !context.isCompilingAgainstJdk8OrLater override fun lower(irClass: IrClass) { if (!irClass.isAnnotationClass) return diff --git a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/AssertionLowering.kt b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/AssertionLowering.kt index d41ba8a2e1b..44d21f5877e 100644 --- a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/AssertionLowering.kt +++ b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/AssertionLowering.kt @@ -45,7 +45,7 @@ private class AssertionLowering(private val context: JvmBackendContext) : override fun lower(irFile: IrFile) { // In legacy mode we treat assertions as inline function calls - if (context.state.assertionsMode != JVMAssertionsMode.LEGACY) + if (context.config.assertionsMode != JVMAssertionsMode.LEGACY) irFile.transformChildren(this, null) } @@ -78,7 +78,7 @@ private class AssertionLowering(private val context: JvmBackendContext) : if (!function.isAssert) return super.visitCall(expression, data) - val mode = context.state.assertionsMode + val mode = context.config.assertionsMode if (mode == JVMAssertionsMode.ALWAYS_DISABLE) return IrCompositeImpl(expression.startOffset, expression.endOffset, context.irBuiltIns.unitType) diff --git a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/BridgeLowering.kt b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/BridgeLowering.kt index 0a8cc10cf95..798359c1c17 100644 --- a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/BridgeLowering.kt +++ b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/BridgeLowering.kt @@ -172,7 +172,7 @@ internal class BridgeLowering(val context: JvmBackendContext) : FileLoweringPass return false // We don't produce bridges for abstract functions in interfaces. - if (isJvmAbstract(context.state.jvmDefaultMode)) { + if (isJvmAbstract(context.config.jvmDefaultMode)) { if (parentAsClass.isJvmInterface) { // If function requires a special bridge, we should record it for generic signatures generation. if (specialBridgeOrNull != null) { @@ -226,7 +226,7 @@ internal class BridgeLowering(val context: JvmBackendContext) : FileLoweringPass // If irFunction is a fake override, we replace it with a stub and redirect all calls to irFunction with calls to the stub // instead. Otherwise, we'll end up calling the special method itself and get into an infinite loop. bridgeTarget = when { - irFunction.isJvmAbstract(context.state.jvmDefaultMode) -> { + irFunction.isJvmAbstract(context.config.jvmDefaultMode) -> { // If the method is abstract, then we simply generate a concrete abstract method // to avoid generating a call to a method which does not exist in the current class. irClass.declarations.remove(irFunction) @@ -312,7 +312,7 @@ internal class BridgeLowering(val context: JvmBackendContext) : FileLoweringPass } } } - } else if (irFunction.isJvmAbstract(context.state.jvmDefaultMode)) { + } else if (irFunction.isJvmAbstract(context.config.jvmDefaultMode)) { // Do not generate bridge methods for abstract methods which do not override a special bridge method. // This matches the behavior of the JVM backend, but it does mean that we generate superfluous bridges // for abstract methods overriding a special bridge for which we do not create a bridge due to, @@ -328,7 +328,7 @@ internal class BridgeLowering(val context: JvmBackendContext) : FileLoweringPass if (irFunction.isFakeOverride) { for (overriddenSymbol in irFunction.overriddenSymbols) { val override = overriddenSymbol.owner - if (override.isJvmAbstract(context.state.jvmDefaultMode)) continue + if (override.isJvmAbstract(context.config.jvmDefaultMode)) continue override.allOverridden() .filter { !it.isFakeOverride } .mapTo(blacklist) { it.jvmMethod } diff --git a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/FunctionReferenceLowering.kt b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/FunctionReferenceLowering.kt index f8da171d199..ad535fb4882 100644 --- a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/FunctionReferenceLowering.kt +++ b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/FunctionReferenceLowering.kt @@ -69,10 +69,10 @@ internal class FunctionReferenceLowering(private val context: JvmBackendContext) } private val shouldGenerateIndySamConversions = - context.state.samConversionsScheme == JvmClosureGenerationScheme.INDY + context.config.samConversionsScheme == JvmClosureGenerationScheme.INDY private val shouldGenerateIndyLambdas = - context.state.lambdasScheme == JvmClosureGenerationScheme.INDY + context.config.lambdasScheme == JvmClosureGenerationScheme.INDY private val shouldGenerateLightweightLambdas = shouldGenerateIndyLambdas && context.state.languageVersionSettings.supportsFeature(LanguageFeature.LightweightLambdas) @@ -461,7 +461,7 @@ internal class FunctionReferenceLowering(private val context: JvmBackendContext) ?: throw AssertionError("Not a SAM class: ${functionSuperClass.owner.render()}") private val useOptimizedSuperClass = - context.state.generateOptimizedCallableReferenceSuperClasses + context.config.generateOptimizedCallableReferenceSuperClasses // This code is partially duplicated in IrUtils getAdapteeFromAdaptedForReferenceFunction // The difference is utils version supports ReturnableBlock, but returns called function instead of call node. diff --git a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/InheritedDefaultMethodsOnClassesLowering.kt b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/InheritedDefaultMethodsOnClassesLowering.kt index b72a4fb8406..3a2b93c5894 100644 --- a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/InheritedDefaultMethodsOnClassesLowering.kt +++ b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/InheritedDefaultMethodsOnClassesLowering.kt @@ -56,7 +56,7 @@ private class InheritedDefaultMethodsOnClassesLowering(val context: JvmBackendCo } } - val implementation = declaration.findInterfaceImplementation(context.state.jvmDefaultMode) + val implementation = declaration.findInterfaceImplementation(context.config.jvmDefaultMode) ?: return declaration return generateDelegationToDefaultImpl(implementation, declaration) } @@ -137,7 +137,7 @@ private class ReplaceDefaultImplsOverriddenSymbols(private val context: JvmBacke // if the overridden symbol has been, or will be, replaced and patch it accordingly. override fun visitSimpleFunction(declaration: IrSimpleFunction) { declaration.overriddenSymbols = declaration.overriddenSymbols.map { symbol -> - if (symbol.owner.findInterfaceImplementation(context.state.jvmDefaultMode) != null) + if (symbol.owner.findInterfaceImplementation(context.config.jvmDefaultMode) != null) context.cachedDeclarations.getDefaultImplsRedirection(symbol.owner).symbol else symbol } @@ -164,7 +164,7 @@ private class InterfaceSuperCallsLowering(val context: JvmBackendContext) : IrEl } val superCallee = expression.symbol.owner - if (superCallee.isDefinitelyNotDefaultImplsMethod(context.state.jvmDefaultMode)) return super.visitCall(expression) + if (superCallee.isDefinitelyNotDefaultImplsMethod(context.config.jvmDefaultMode)) return super.visitCall(expression) val redirectTarget = context.cachedDeclarations.getDefaultImplsFunction(superCallee) val newCall = createDelegatingCallWithPlaceholderTypeArguments(expression, redirectTarget, context.irBuiltIns) @@ -214,7 +214,7 @@ private class InterfaceDefaultCallsLowering(val context: JvmBackendContext) : Ir if (!callee.hasInterfaceParent() || callee.origin != IrDeclarationOrigin.FUNCTION_FOR_DEFAULT_PARAMETER || - callee.isSimpleFunctionCompiledToJvmDefault(context.state.jvmDefaultMode) + callee.isSimpleFunctionCompiledToJvmDefault(context.config.jvmDefaultMode) ) { return super.visitCall(expression) } diff --git a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/InterfaceLowering.kt b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/InterfaceLowering.kt index 5ae72402668..76c7ec36e6f 100644 --- a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/InterfaceLowering.kt +++ b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/InterfaceLowering.kt @@ -60,7 +60,7 @@ internal class InterfaceLowering(val context: JvmBackendContext) : IrElementTran } private fun handleInterface(irClass: IrClass) { - val jvmDefaultMode = context.state.jvmDefaultMode + val jvmDefaultMode = context.config.jvmDefaultMode val isCompatibilityMode = (jvmDefaultMode.isCompatibility && !irClass.hasJvmDefaultNoCompatibilityAnnotation()) || (jvmDefaultMode == JvmDefaultMode.ALL_INCOMPATIBLE && irClass.hasJvmDefaultWithCompatibilityAnnotation()) diff --git a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmArgumentNullabilityAssertionsLowering.kt b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmArgumentNullabilityAssertionsLowering.kt index c654b5d08c0..658a3483799 100644 --- a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmArgumentNullabilityAssertionsLowering.kt +++ b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmArgumentNullabilityAssertionsLowering.kt @@ -33,9 +33,9 @@ private enum class AssertionScope { private class JvmArgumentNullabilityAssertionsLowering(context: JvmBackendContext) : FileLoweringPass, IrElementTransformer { - private val isWithUnifiedNullChecks = context.state.unifiedNullChecks - private val isCallAssertionsDisabled = context.state.isCallAssertionsDisabled - private val isReceiverAssertionsDisabled = context.state.isReceiverAssertionsDisabled + private val isWithUnifiedNullChecks = context.config.unifiedNullChecks + private val isCallAssertionsDisabled = context.config.isCallAssertionsDisabled + private val isReceiverAssertionsDisabled = context.config.isReceiverAssertionsDisabled private val specialBridgeMethods = SpecialBridgeMethods(context) diff --git a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmPropertiesLowering.kt b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmPropertiesLowering.kt index 04acfabadee..6fd352e6a46 100644 --- a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmPropertiesLowering.kt +++ b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmPropertiesLowering.kt @@ -223,7 +223,7 @@ class JvmPropertiesLowering(private val backendContext: JvmBackendContext) : IrE if (getter != null) { val needsMangling = getter.extensionReceiverParameter?.type?.getRequiresMangling(includeInline = true, includeMFVC = false) == true || - (state.functionsWithInlineClassReturnTypesMangled && getter.hasMangledReturnType) + (config.functionsWithInlineClassReturnTypesMangled && getter.hasMangledReturnType) val mangled = if (needsMangling) inlineClassReplacements.getReplacementFunction(getter) else null defaultMethodSignatureMapper.mapFunctionName(mangled ?: getter) } else JvmAbi.getterName(property.name.asString()) diff --git a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmStringConcatenationLowering.kt b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmStringConcatenationLowering.kt index ead6dab2a26..60823b2d6f8 100644 --- a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmStringConcatenationLowering.kt +++ b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmStringConcatenationLowering.kt @@ -28,7 +28,7 @@ import org.jetbrains.kotlin.ir.visitors.transformChildrenVoid internal val jvmStringConcatenationLowering = makeIrFilePhase( { context: JvmBackendContext -> - if (!context.state.runtimeStringConcat.isDynamic) + if (!context.config.runtimeStringConcat.isDynamic) JvmStringConcatenationLowering(context) else JvmDynamicStringConcatenationLowering(context) diff --git a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmValueClassAbstractLowering.kt b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmValueClassAbstractLowering.kt index 0bd5722cf08..23e7474327b 100644 --- a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmValueClassAbstractLowering.kt +++ b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmValueClassAbstractLowering.kt @@ -90,8 +90,8 @@ internal abstract class JvmValueClassAbstractLowering( private fun IrFunction.hashSuffix(): String? = InlineClassAbi.hashSuffix( this, - context.state.functionsWithInlineClassReturnTypesMangled, - context.state.useOldManglingSchemeForFunctionsWithInlineClassesInSignatures + context.config.functionsWithInlineClassReturnTypesMangled, + context.config.useOldManglingSchemeForFunctionsWithInlineClassesInSignatures ) protected abstract fun transformSecondaryConstructorFlat(constructor: IrConstructor, replacement: IrSimpleFunction): List @@ -192,7 +192,7 @@ internal abstract class JvmValueClassAbstractLowering( useOldMangleRules = false ) // If the original function has signature which need mangling we still need to replace it with a mangled version. - (!function.isFakeOverride || function.findInterfaceImplementation(context.state.jvmDefaultMode) != null) && when (specificMangle) { + (!function.isFakeOverride || function.findInterfaceImplementation(context.config.jvmDefaultMode) != null) && when (specificMangle) { SpecificMangle.Inline -> function.signatureRequiresMangling(includeInline = true, includeMFVC = false) SpecificMangle.MultiField -> function.signatureRequiresMangling(includeInline = false, includeMFVC = true) } -> replacement.name @@ -224,7 +224,7 @@ internal abstract class JvmValueClassAbstractLowering( private fun IrSimpleFunction.signatureRequiresMangling(includeInline: Boolean = true, includeMFVC: Boolean = true) = fullValueParameterList.any { it.type.getRequiresMangling(includeInline, includeMFVC) } || - context.state.functionsWithInlineClassReturnTypesMangled && + context.config.functionsWithInlineClassReturnTypesMangled && returnType.getRequiresMangling(includeInline = includeInline, includeMFVC = false) protected fun typedArgumentList(function: IrFunction, expression: IrMemberAccessExpression<*>) = listOfNotNull( diff --git a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/PropertyReferenceDelegationLowering.kt b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/PropertyReferenceDelegationLowering.kt index 2a176614cee..02589b5db1d 100644 --- a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/PropertyReferenceDelegationLowering.kt +++ b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/PropertyReferenceDelegationLowering.kt @@ -35,7 +35,7 @@ internal val propertyReferenceDelegationPhase = makeIrFilePhase( private class PropertyReferenceDelegationLowering(val context: JvmBackendContext) : FileLoweringPass { override fun lower(irFile: IrFile) { - if (!context.state.generateOptimizedCallableReferenceSuperClasses) return + if (!context.config.generateOptimizedCallableReferenceSuperClasses) return irFile.transform(PropertyReferenceDelegationTransformer(context), null) } } diff --git a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/PropertyReferenceLowering.kt b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/PropertyReferenceLowering.kt index 706a5e216f4..96d2254645e 100644 --- a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/PropertyReferenceLowering.kt +++ b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/PropertyReferenceLowering.kt @@ -92,7 +92,7 @@ internal class PropertyReferenceLowering(val context: JvmBackendContext) : IrEle context.ir.symbols.array.createType(false, listOf(makeTypeProjection(kPropertyStarType, Variance.OUT_VARIANCE))) private val useOptimizedSuperClass = - context.state.generateOptimizedCallableReferenceSuperClasses + context.config.generateOptimizedCallableReferenceSuperClasses private val IrClass.isSynthetic get() = metadata !is MetadataSource.File && metadata !is MetadataSource.Class && metadata !is MetadataSource.Script @@ -227,7 +227,7 @@ internal class PropertyReferenceLowering(val context: JvmBackendContext) : IrEle isFinal = true isStatic = true visibility = - if (irClass.isInterface && context.state.jvmDefaultMode.forAllMethodsWithBody) DescriptorVisibilities.PUBLIC else JavaDescriptorVisibilities.PACKAGE_VISIBILITY + if (irClass.isInterface && context.config.jvmDefaultMode.forAllMethodsWithBody) DescriptorVisibilities.PUBLIC else JavaDescriptorVisibilities.PACKAGE_VISIBILITY } val localProperties = mutableListOf() diff --git a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/SingletonOrConstantDelegationLowering.kt b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/SingletonOrConstantDelegationLowering.kt index 5d9e2345d87..7486a5115a5 100644 --- a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/SingletonOrConstantDelegationLowering.kt +++ b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/SingletonOrConstantDelegationLowering.kt @@ -31,7 +31,7 @@ internal val singletonOrConstantDelegationPhase = makeIrFilePhase( private class SingletonOrConstantDelegationLowering(val context: JvmBackendContext) : FileLoweringPass { override fun lower(irFile: IrFile) { - if (!context.state.generateOptimizedCallableReferenceSuperClasses) return + if (!context.config.generateOptimizedCallableReferenceSuperClasses) return irFile.transform(SingletonOrConstantDelegationTransformer(context), null) } } diff --git a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/TypeOperatorLowering.kt b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/TypeOperatorLowering.kt index 78b4615da61..877d9c6c4cc 100644 --- a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/TypeOperatorLowering.kt +++ b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/TypeOperatorLowering.kt @@ -18,7 +18,6 @@ import org.jetbrains.kotlin.backend.jvm.JvmBackendContext import org.jetbrains.kotlin.backend.jvm.JvmLoweredDeclarationOrigin import org.jetbrains.kotlin.backend.jvm.ir.* import org.jetbrains.kotlin.backend.jvm.unboxInlineClass -import org.jetbrains.kotlin.config.LanguageFeature import org.jetbrains.kotlin.descriptors.DescriptorVisibilities import org.jetbrains.kotlin.ir.IrElement import org.jetbrains.kotlin.ir.IrStatement @@ -97,7 +96,7 @@ private class TypeOperatorLowering(private val backendContext: JvmBackendContext with(builder) { irLetS(argument, irType = context.irBuiltIns.anyNType) { tmp -> val message = irString("null cannot be cast to non-null type ${type.render()}") - if (backendContext.state.unifiedNullChecks) { + if (backendContext.config.unifiedNullChecks) { // Avoid branching to improve code coverage (KT-27427). // We have to generate a null check here, because even if argument is of non-null type, // it can be uninitialized value, which is 'null' for reference types in JMM. @@ -764,7 +763,7 @@ private class TypeOperatorLowering(private val backendContext: JvmBackendContext } private fun IrBuilderWithScope.computeNotNullAssertionText(typeOperatorCall: IrTypeOperatorCall): String? { - if (backendContext.state.noSourceCodeInNotNullAssertionExceptions) { + if (backendContext.config.noSourceCodeInNotNullAssertionExceptions) { return when (val argument = typeOperatorCall.argument) { is IrCall -> "${argument.symbol.owner.name.asString()}(...)" is IrGetField -> argument.symbol.owner.name.asString() @@ -818,7 +817,7 @@ private class TypeOperatorLowering(private val backendContext: JvmBackendContext backendContext.ir.symbols.throwTypeCastException private val checkExpressionValueIsNotNull: IrSimpleFunctionSymbol = - if (backendContext.state.unifiedNullChecks) + if (backendContext.config.unifiedNullChecks) backendContext.ir.symbols.checkNotNullExpressionValue else backendContext.ir.symbols.checkExpressionValueIsNotNull diff --git a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/indy/LambdaMetafactoryArguments.kt b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/indy/LambdaMetafactoryArguments.kt index 43f1de1e9da..f0fbd1a8dff 100644 --- a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/indy/LambdaMetafactoryArguments.kt +++ b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/indy/LambdaMetafactoryArguments.kt @@ -153,7 +153,7 @@ internal class LambdaMetafactoryArgumentsBuilder( // In this case the corresponding method might be inaccessible in the context where it's referenced (see KT-48954). // For now, just prohibit referencing methods from package-private Java classes through indy (without precise accessibility check). if (implFun is IrSimpleFunction) { - val baseFun = findSuperDeclaration(implFun, false, context.state.jvmDefaultMode) + val baseFun = findSuperDeclaration(implFun, false, context.config.jvmDefaultMode) val baseFunClass = baseFun.parent as? IrClass if (baseFunClass != null && baseFunClass.visibility == JavaDescriptorVisibilities.PACKAGE_VISIBILITY) { functionHazard = true @@ -234,13 +234,13 @@ internal class LambdaMetafactoryArgumentsBuilder( continue val irImplFun = if (irMemberFun.isFakeOverride) - irMemberFun.findInterfaceImplementation(context.state.jvmDefaultMode) + irMemberFun.findInterfaceImplementation(context.config.jvmDefaultMode) ?: continue else irMemberFun if (irImplFun.origin == IrDeclarationOrigin.IR_EXTERNAL_JAVA_DECLARATION_STUB) continue - if (!irImplFun.isCompiledToJvmDefault(context.state.jvmDefaultMode)) + if (!irImplFun.isCompiledToJvmDefault(context.config.jvmDefaultMode)) return true } return false diff --git a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/irValidation.kt b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/irValidation.kt index 32cbfd517f5..a289fb81cf6 100644 --- a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/irValidation.kt +++ b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/irValidation.kt @@ -10,6 +10,6 @@ import org.jetbrains.kotlin.backend.jvm.JvmBackendContext import org.jetbrains.kotlin.ir.declarations.IrModuleFragment fun validateIr(context: JvmBackendContext, module: IrModuleFragment) { - if (!context.state.shouldValidateIr) return + if (!context.config.shouldValidateIr) return validationCallback(context, module, checkProperties = true) -} \ No newline at end of file +} diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmBackendContext.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmBackendContext.kt index c564eed5822..596a2d88a0d 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmBackendContext.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmBackendContext.kt @@ -21,6 +21,7 @@ import org.jetbrains.kotlin.backend.jvm.mapping.IrTypeMapper import org.jetbrains.kotlin.backend.jvm.mapping.MethodSignatureMapper import org.jetbrains.kotlin.codegen.inline.SMAP import org.jetbrains.kotlin.codegen.state.GenerationState +import org.jetbrains.kotlin.codegen.state.JvmBackendConfig import org.jetbrains.kotlin.descriptors.ClassDescriptor import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor import org.jetbrains.kotlin.ir.IrBuiltIns @@ -80,6 +81,8 @@ class JvmBackendContext( val newParameterToCaptured: Map, ) + val config: JvmBackendConfig = state.config + // If not-null, this is populated by LocalDeclarationsLowering with the intermediate data // allowing mapping from local function captures to parameters and accurate transformation // of calls to local functions from code fragments (i.e. the expression evaluator). @@ -176,7 +179,7 @@ class JvmBackendContext( val staticDefaultStubs = ConcurrentHashMap() - val inlineClassReplacements = MemoizedInlineClassReplacements(state.functionsWithInlineClassReturnTypesMangled, irFactory, this) + val inlineClassReplacements = MemoizedInlineClassReplacements(config.functionsWithInlineClassReturnTypesMangled, irFactory, this) val multiFieldValueClassReplacements = MemoizedMultiFieldValueClassReplacements(irFactory, this) diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmSymbols.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmSymbols.kt index 3ff4a0de721..5184da76b94 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmSymbols.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmSymbols.kt @@ -74,7 +74,7 @@ class JvmSymbols( // (they are expected to be provided at run-time by the corresponding bootstrap method). val kotlinJvmInternalInvokeDynamicPackage: IrPackageFragment = createPackage(FqName("kotlin.jvm.internal.invokeDynamic")) - private val generateOptimizedCallableReferenceSuperClasses = context.state.generateOptimizedCallableReferenceSuperClasses + private val generateOptimizedCallableReferenceSuperClasses = context.config.generateOptimizedCallableReferenceSuperClasses private fun createPackage(fqName: FqName): IrPackageFragment = IrExternalPackageFragmentImpl.createEmptyExternalPackageFragment(context.state.module, fqName) diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MemoizedInlineClassReplacements.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MemoizedInlineClassReplacements.kt index feb56ebde36..18d540ed2c2 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MemoizedInlineClassReplacements.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MemoizedInlineClassReplacements.kt @@ -220,7 +220,7 @@ class MemoizedInlineClassReplacements( noFakeOverride: Boolean = false, body: IrFunction.() -> Unit ): IrSimpleFunction { - val useOldManglingScheme = context.state.useOldManglingSchemeForFunctionsWithInlineClassesInSignatures + val useOldManglingScheme = context.config.useOldManglingSchemeForFunctionsWithInlineClassesInSignatures val replacement = buildReplacementInner(function, replacementOrigin, noFakeOverride, useOldManglingScheme, body) // When using the new mangling scheme we might run into dependencies using the old scheme // for which we will fall back to the old mangling scheme as well. diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MemoizedMultiFieldValueClassReplacements.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MemoizedMultiFieldValueClassReplacements.kt index a7acf5b0c37..8c9fe3ad920 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MemoizedMultiFieldValueClassReplacements.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MemoizedMultiFieldValueClassReplacements.kt @@ -282,7 +282,7 @@ class MemoizedMultiFieldValueClassReplacements( && function.fullValueParameterList.any { it.type.needsMfvcFlattening() } && run { if (!function.isFakeOverride) return@run true - val superDeclaration = findSuperDeclaration(function, false, context.state.jvmDefaultMode) + val superDeclaration = findSuperDeclaration(function, false, context.config.jvmDefaultMode) getReplacementFunction(superDeclaration) != null } -> createMethodReplacement(function) diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MemoizedValueClassAbstractReplacements.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MemoizedValueClassAbstractReplacements.kt index 298a8015505..dacf4f68148 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MemoizedValueClassAbstractReplacements.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MemoizedValueClassAbstractReplacements.kt @@ -53,7 +53,7 @@ abstract class MemoizedValueClassAbstractReplacements( // It is a JVM default interface method if one of the following conditions are true: // - it is a Java method, // - it is a Kotlin function compiled to JVM default interface method. - return overridden.isFromJava() || overridden.isCompiledToJvmDefault(context.state.jvmDefaultMode) + return overridden.isFromJava() || overridden.isCompiledToJvmDefault(context.config.jvmDefaultMode) } protected abstract fun createStaticReplacement(function: IrFunction): IrSimpleFunction diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/ir/JvmIrInlineUtils.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/ir/JvmIrInlineUtils.kt index f75f340a731..c33d7497e3a 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/ir/JvmIrInlineUtils.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/ir/JvmIrInlineUtils.kt @@ -67,7 +67,7 @@ fun IrStatement.unwrapInlineLambda(): IrFunctionReference? = when (this) { } fun IrFunction.isInlineFunctionCall(context: JvmBackendContext): Boolean = - (!context.state.isInlineDisabled || typeParameters.any { it.isReified }) && (isInline || isInlineArrayConstructor(context.irBuiltIns)) + (!context.config.isInlineDisabled || typeParameters.any { it.isReified }) && (isInline || isInlineArrayConstructor(context.irBuiltIns)) fun IrDeclaration.isInlineOnly(): Boolean = this is IrFunction && ( diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/mapping/MethodSignatureMapper.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/mapping/MethodSignatureMapper.kt index d64136277f3..82df40c043b 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/mapping/MethodSignatureMapper.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/mapping/MethodSignatureMapper.kt @@ -444,7 +444,7 @@ class MethodSignatureMapper(private val context: JvmBackendContext, private val mapAsmMethod(findSuperDeclaration(function, isSuperCall)) private fun findSuperDeclaration(function: IrSimpleFunction, isSuperCall: Boolean): IrSimpleFunction = - findSuperDeclaration(function, isSuperCall, context.state.jvmDefaultMode) + findSuperDeclaration(function, isSuperCall, context.config.jvmDefaultMode) private fun getJvmMethodNameIfSpecial(irFunction: IrSimpleFunction): String? { if ( @@ -522,7 +522,7 @@ class MethodSignatureMapper(private val context: JvmBackendContext, private val is IrConstructor -> irFun is IrSimpleFunction -> - findSuperDeclaration(irFun, false, context.state.jvmDefaultMode) + findSuperDeclaration(irFun, false, context.config.jvmDefaultMode) else -> throw AssertionError("Simple function or constructor expected: ${irFun.render()}") } diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/metadata/DescriptorMetadataSerializer.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/metadata/DescriptorMetadataSerializer.kt index f3b13422998..251ca523500 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/metadata/DescriptorMetadataSerializer.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/metadata/DescriptorMetadataSerializer.kt @@ -59,7 +59,7 @@ class DescriptorMetadataSerializer( context.state.bindingTrace.record( CodegenBinding.DELEGATED_PROPERTIES_WITH_METADATA, // key for local delegated properties metadata in interfaces depends on jvmDefaultMode - if (irClass.isInterface && !context.state.jvmDefaultMode.forAllMethodsWithBody) context.defaultTypeMapper.mapClass( + if (irClass.isInterface && !context.config.jvmDefaultMode.forAllMethodsWithBody) context.defaultTypeMapper.mapClass( context.cachedDeclarations.getDefaultImplsClass( irClass ) diff --git a/plugins/android-extensions/android-extensions-compiler/src/org/jetbrains/kotlin/android/parcel/ParcelableCodegenExtension.kt b/plugins/android-extensions/android-extensions-compiler/src/org/jetbrains/kotlin/android/parcel/ParcelableCodegenExtension.kt index 2247f5551cd..ee5fbfeb510 100644 --- a/plugins/android-extensions/android-extensions-compiler/src/org/jetbrains/kotlin/android/parcel/ParcelableCodegenExtension.kt +++ b/plugins/android-extensions/android-extensions-compiler/src/org/jetbrains/kotlin/android/parcel/ParcelableCodegenExtension.kt @@ -316,7 +316,7 @@ open class ParcelableCodegenExtension : ParcelableExtensionBase, ExpressionCodeg writeNewArrayMethod(codegenForCreator, parcelableClass, parcelableCreatorClassType, creatorClass, parcelerObject) writeCreateFromParcel(codegenForCreator, parcelableClass, parcelableCreatorClassType, creatorClass, parcelClassType, parcelAsmType, parcelerObject, properties) - classBuilderForCreator.done(codegen.state.generateSmapCopyToAnnotation) + classBuilderForCreator.done(codegen.state.config.generateSmapCopyToAnnotation) } private fun writeCreatorConstructor(codegen: ImplementationBodyCodegen, creatorClass: ClassDescriptor, creatorAsmType: Type) { diff --git a/plugins/kotlinx-serialization/kotlinx-serialization.backend/src/org/jetbrains/kotlinx/serialization/compiler/backend/jvm/JVMCodegenUtil.kt b/plugins/kotlinx-serialization/kotlinx-serialization.backend/src/org/jetbrains/kotlinx/serialization/compiler/backend/jvm/JVMCodegenUtil.kt index 81a661177dc..6aa38d75852 100644 --- a/plugins/kotlinx-serialization/kotlinx-serialization.backend/src/org/jetbrains/kotlinx/serialization/compiler/backend/jvm/JVMCodegenUtil.kt +++ b/plugins/kotlinx-serialization/kotlinx-serialization.backend/src/org/jetbrains/kotlinx/serialization/compiler/backend/jvm/JVMCodegenUtil.kt @@ -658,7 +658,7 @@ internal fun createSingletonLambda( ) lambdaCodegen.v.defineClass( null, - outerClassCodegen.state.classFileVersion, + outerClassCodegen.state.config.classFileVersion, Opcodes.ACC_FINAL or Opcodes.ACC_SUPER or Opcodes.ACC_SYNTHETIC, lambdaType.internalName, "L${jvmLambdaType.internalName};L${function0Type.internalName};>;", @@ -773,7 +773,7 @@ internal fun createSingletonLambda( } writeSyntheticClassMetadata(lambdaClassBuilder, lambdaCodegen.state, false) - lambdaClassBuilder.done(lambdaCodegen.state.generateSmapCopyToAnnotation) + lambdaClassBuilder.done(lambdaCodegen.state.config.generateSmapCopyToAnnotation) return lambdaType }