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 }