From 6ad159bb0198442ab2ab5ceb94a5dd47289d6a81 Mon Sep 17 00:00:00 2001 From: Dmitry Petrov Date: Sat, 11 Jan 2020 00:56:04 +0300 Subject: [PATCH] JVM: Rewrite companion object accessor generation Old version handled only private companions correctly. Some situations require multiple companion object accessors (including accessors for protected companion objects from supertypes) to be generated in the corresponding class. --- .../kotlin/codegen/ExpressionCodegen.java | 139 +++++++++++++----- .../kotlin/codegen/JvmCodegenUtil.java | 42 +++--- .../kotlin/codegen/MemberCodegen.java | 27 +++- .../codegen/context/CodegenContext.java | 52 +++---- .../kotlin/codegen/context/MethodContext.java | 1 + .../accessFromInlineLambda.kt | 37 +++++ .../anonymousObjectInPropertyInitializer.kt | 37 +++++ .../fromAnonymousObjectInNestedClass.kt | 34 +++++ .../fromInitBlock.kt | 31 ++++ .../fromInitBlockOfNestedClass.kt | 33 +++++ .../fromInlineLambdaInNestedClass.kt | 35 +++++ ...rotectedCompanionAndOwnPrivateCompanion.kt | 28 ++++ ...itedProtectedCompanionsReferencedByName.kt | 36 +++++ .../lambdaInPropertyInitializer.kt | 35 +++++ .../twoInheritedProtectedCompanions.kt | 35 +++++ .../withCompanionObjectBase.kt | 26 ++++ .../withMultipleNestedCompanionObjectBases.kt | 44 ++++++ .../codegen/BlackBoxCodegenTestGenerated.java | 73 +++++++++ .../LightAnalysisModeTestGenerated.java | 73 +++++++++ .../ir/FirBlackBoxCodegenTestGenerated.java | 73 +++++++++ .../ir/IrBlackBoxCodegenTestGenerated.java | 73 +++++++++ .../IrJsCodegenBoxTestGenerated.java | 73 +++++++++ .../semantics/JsCodegenBoxTestGenerated.java | 73 +++++++++ 23 files changed, 1009 insertions(+), 101 deletions(-) create mode 100644 compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/accessFromInlineLambda.kt create mode 100644 compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/anonymousObjectInPropertyInitializer.kt create mode 100644 compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/fromAnonymousObjectInNestedClass.kt create mode 100644 compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/fromInitBlock.kt create mode 100644 compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/fromInitBlockOfNestedClass.kt create mode 100644 compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/fromInlineLambdaInNestedClass.kt create mode 100644 compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/inheritedProtectedCompanionAndOwnPrivateCompanion.kt create mode 100644 compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/inheritedProtectedCompanionsReferencedByName.kt create mode 100644 compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/lambdaInPropertyInitializer.kt create mode 100644 compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/twoInheritedProtectedCompanions.kt create mode 100644 compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/withCompanionObjectBase.kt create mode 100644 compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/withMultipleNestedCompanionObjectBases.kt diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java index df2384b643f..c1e2a596125 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java @@ -1851,10 +1851,9 @@ public class ExpressionCodegen extends KtVisitor impleme } if (descriptor instanceof TypeAliasDescriptor) { ClassDescriptor classDescriptor = ((TypeAliasDescriptor) descriptor).getClassDescriptor(); - if (classDescriptor == null) { - throw new IllegalStateException("Type alias " + descriptor + " static member reference should be rejected by type checker, " + - "since there is no class corresponding to this type alias."); - } + assert classDescriptor != null : + "Type alias " + descriptor + " static member reference should be rejected by type checker, " + + "since there is no class corresponding to this type alias."; descriptor = classDescriptor; } @@ -1863,8 +1862,8 @@ public class ExpressionCodegen extends KtVisitor impleme if (shouldGenerateSingletonAsThisOrOuterFromContext(classDescriptor)) { return generateThisOrOuterFromContext(classDescriptor, false, false); } - if (isCompanionObject(classDescriptor) && !couldUseDirectAccessToCompanionObject(classDescriptor, context)) { - return generateAccessorCallForCompanionObject(classDescriptor); + if (isCompanionObject(classDescriptor)) { + return generateCompanionObjectInstance(classDescriptor); } if (isObject(classDescriptor)) { return StackValue.singleton(classDescriptor, typeMapper); @@ -1874,7 +1873,7 @@ public class ExpressionCodegen extends KtVisitor impleme } ClassDescriptor companionObjectDescriptor = classDescriptor.getCompanionObjectDescriptor(); if (companionObjectDescriptor != null) { - return StackValue.singleton(companionObjectDescriptor, typeMapper); + return generateCompanionObjectInstance(companionObjectDescriptor); } return StackValue.none(); } @@ -1886,6 +1885,41 @@ public class ExpressionCodegen extends KtVisitor impleme throw new UnsupportedOperationException("don't know how to generate reference " + descriptor); } + private StackValue generateCompanionObjectInstance(ClassDescriptor companionObjectDescriptor) { + assert isCompanionObject(companionObjectDescriptor) : + "Companion object expected: " + companionObjectDescriptor; + + CodegenContext accessorContext = getContextForCompanionObjectAccessorIfRequiredOrNull(companionObjectDescriptor, context); + if (accessorContext == null) { + return StackValue.singleton(companionObjectDescriptor, typeMapper); + } + + // Should use accessor + DeclarationDescriptor accessorContextDescriptor = accessorContext.getContextDescriptor(); + assert accessorContextDescriptor instanceof ClassDescriptor : + "Expected to put accessor for companion object " + companionObjectDescriptor + + " into a class, but got " + accessorContextDescriptor; + + accessorContext.getOrCreateAccessorForCompanionObject(companionObjectDescriptor); + + Type hostClassType = typeMapper.mapClass((ClassDescriptor) accessorContextDescriptor); + Type companionObjectType = typeMapper.mapClass(companionObjectDescriptor); + + // TODO we actually have corresponding accessor descriptor, it might be a better idea to use general method call generation. + return StackValue.operation( + companionObjectType, + companionObjectDescriptor.getDefaultType(), + v1 -> { + v1.invokestatic( + hostClassType.getInternalName(), + getCompanionObjectAccessorName(companionObjectDescriptor), + Type.getMethodDescriptor(companionObjectType), + /* itf */ false + ); + return null; + }); + } + private boolean shouldGenerateSingletonAsThisOrOuterFromContext(ClassDescriptor classDescriptor) { if (!isPossiblyUninitializedSingleton(classDescriptor)) return false; if (!isInsideSingleton(classDescriptor)) return false; @@ -2479,6 +2513,23 @@ public class ExpressionCodegen extends KtVisitor impleme return null; } + @Nullable + public static CodegenContext getCompanionObjectContextSubclassOf(ClassDescriptor descriptor, CodegenContext context) { + for (CodegenContext current = context; current != null; current = current.getParentContext()) { + if (!(current instanceof ClassContext)) continue; + + ClassContext classContext = (ClassContext) current; + ClassDescriptor companionObject = classContext.getContextDescriptor().getCompanionObjectDescriptor(); + if (companionObject == null) continue; + + if (DescriptorUtils.isSubclass(companionObject, descriptor)) { + return classContext.getCompanionObjectContext(); + } + } + + return null; + } + @NotNull Callable resolveToCallable(@NotNull FunctionDescriptor fd, boolean superCall, @NotNull ResolvedCall resolvedCall) { IntrinsicMethod intrinsic = state.getIntrinsics().getIntrinsic(fd); @@ -2799,11 +2850,8 @@ public class ExpressionCodegen extends KtVisitor impleme else if (isPossiblyUninitializedSingleton(receiverDescriptor) && isInsideSingleton(receiverDescriptor)) { return generateThisOrOuterFromContext(receiverDescriptor, false, false); } - else if (couldUseDirectAccessToCompanionObject(receiverDescriptor, context)) { - return StackValue.singleton(receiverDescriptor, typeMapper); - } else { - return generateAccessorCallForCompanionObject(receiverDescriptor); + return generateCompanionObjectInstance(receiverDescriptor); } } else if (receiverDescriptor instanceof ScriptDescriptor) { @@ -2814,36 +2862,53 @@ public class ExpressionCodegen extends KtVisitor impleme } } - @NotNull - private StackValue generateAccessorCallForCompanionObject(@NotNull ClassDescriptor companionObjectDescriptor) { - DeclarationDescriptor hostClassDescriptor = companionObjectDescriptor.getContainingDeclaration(); - assert hostClassDescriptor instanceof ClassDescriptor : - "Containing declaration of the companion object " + companionObjectDescriptor + - ": expected a class, actual: " + hostClassDescriptor; + private static CodegenContext getContextForCompanionObjectAccessorIfRequiredOrNull( + @NotNull ClassDescriptor companionObjectDescriptor, + @NotNull CodegenContext contextBeforeInline + ) { + if (isDebuggerContext(contextBeforeInline)) { + return null; + } - CodegenContext hostClassContext = context.findParentContextWithDescriptor(hostClassDescriptor); - assert hostClassContext != null : - "Host class context for " + hostClassDescriptor + " not found in context hierarchy for " + context; + int accessFlag = AsmUtil.getVisibilityAccessFlag(companionObjectDescriptor); - hostClassContext.markCompanionObjectDescriptorWithAccessorRequired(companionObjectDescriptor); + CodegenContext context = contextBeforeInline.getFirstCrossInlineOrNonInlineContext(); + boolean isInlineMethodContext = context.isInlineMethodContext(); + DeclarationDescriptor contextDescriptor = context.getContextDescriptor(); - Type hostClassType = typeMapper.mapClass((ClassifierDescriptor) hostClassDescriptor); - Type companionObjectType = typeMapper.mapClass(companionObjectDescriptor); + ClassDescriptor containingClassOfCompanionObject = DescriptorUtils.getContainingClass(companionObjectDescriptor); - // TODO given that we actually have corresponding AccessorForCompanionObjectInstanceFieldDescriptor, - // it might be a better idea to use general method call generation - return StackValue.operation( - companionObjectType, - companionObjectDescriptor.getDefaultType(), - v -> { - v.invokestatic( - hostClassType.getInternalName(), - getCompanionObjectAccessorName(companionObjectDescriptor), - Type.getMethodDescriptor(companionObjectType), - /* itf */ false - ); - return null; - }); + if ((accessFlag & ACC_PRIVATE) != 0) { + // Private companion object + if (!isInlineMethodContext && contextDescriptor.getContainingDeclaration() == containingClassOfCompanionObject) { + return null; + } + return context.findParentContextWithDescriptor(containingClassOfCompanionObject); + } else if ((accessFlag & ACC_PROTECTED) != 0) { + // Protected companion object + if (!isInlineMethodContext && canAccessProtectedMembers(contextDescriptor, containingClassOfCompanionObject)) { + return null; + } + CodegenContext accessorContext = getParentContextSubclassOf(containingClassOfCompanionObject, context); + if (accessorContext == null) { + accessorContext = getCompanionObjectContextSubclassOf(containingClassOfCompanionObject, context); + } + assert accessorContext != null : + "Class context for accessor to a protected companion object " + companionObjectDescriptor + " not found:\n" + + JvmCodegenUtil.dumpContextHierarchy(context); + return accessorContext; + } else { + // Non-protected && non-private companion object + return null; + } + } + + private static boolean canAccessProtectedMembers(DeclarationDescriptor contextDescriptor, ClassDescriptor classDescriptor) { + DeclarationDescriptor containingDeclaration = contextDescriptor.getContainingDeclaration(); + return containingDeclaration == classDescriptor || + JvmCodegenUtil.isInSamePackage(contextDescriptor, classDescriptor) || + containingDeclaration instanceof ClassDescriptor && + DescriptorUtils.isSubclass((ClassDescriptor) containingDeclaration, classDescriptor); } @NotNull diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/JvmCodegenUtil.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/JvmCodegenUtil.java index 9bb118a3aa4..121e0760250 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/JvmCodegenUtil.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/JvmCodegenUtil.java @@ -151,29 +151,6 @@ public class JvmCodegenUtil { return propertyDescriptor.isConst() || hasJvmFieldAnnotation(propertyDescriptor); } - public static boolean couldUseDirectAccessToCompanionObject( - @NotNull ClassDescriptor companionObjectDescriptor, - @NotNull MethodContext contextBeforeInline - ) { - if (!Visibilities.isPrivate(companionObjectDescriptor.getVisibility())) { - // Non-private companion object can be directly accessed anywhere it's allowed by the front-end. - return true; - } - - if (isDebuggerContext(contextBeforeInline)) { - return true; - } - - CodegenContext context = contextBeforeInline.getFirstCrossInlineOrNonInlineContext(); - if (context.isInlineMethodContext()) { - // Inline method can be called from a nested class. - return false; - } - - // Private companion object is directly accessible only from the corresponding class - return context.getContextDescriptor().getContainingDeclaration() == companionObjectDescriptor.getContainingDeclaration(); - } - public static String getCompanionObjectAccessorName(@NotNull ClassDescriptor companionObjectDescriptor) { return "access$" + companionObjectDescriptor.getName(); } @@ -422,4 +399,23 @@ public class JvmCodegenUtil { return ((DeserializedClassDescriptor) descriptor).getMetadataVersion().isAtLeast(1, 1, 16); } } + + public static boolean isInSamePackage(DeclarationDescriptor descriptor1, DeclarationDescriptor descriptor2) { + PackageFragmentDescriptor package1 = DescriptorUtils.getParentOfType(descriptor1, PackageFragmentDescriptor.class, false); + PackageFragmentDescriptor package2 = DescriptorUtils.getParentOfType(descriptor2, PackageFragmentDescriptor.class, false); + + return package1 != null && package2 != null && + package1.getFqName().equals(package2.getFqName()); + } + + // Used mainly for debugging purposes. + @SuppressWarnings("unused") + public static String dumpContextHierarchy(CodegenContext context) { + StringBuilder result = new StringBuilder(); + int i = 0; + for (CodegenContext current = context; current != null; current = current.getParentContext(), ++i) { + result.append(i).append(": ").append(current).append('\n'); + } + return result.toString(); + } } diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/MemberCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/MemberCodegen.java index b6d6e71c0cb..7a4633dde3d 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/MemberCodegen.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/MemberCodegen.java @@ -33,6 +33,7 @@ import org.jetbrains.kotlin.psi.*; import org.jetbrains.kotlin.psi.synthetics.SyntheticClassOrObjectDescriptor; import org.jetbrains.kotlin.resolve.BindingContext; import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils; +import org.jetbrains.kotlin.resolve.DescriptorUtils; import org.jetbrains.kotlin.resolve.InlineClassesUtilsKt; import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall; import org.jetbrains.kotlin.resolve.constants.ConstantValue; @@ -52,10 +53,7 @@ import org.jetbrains.org.objectweb.asm.Type; import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter; import org.jetbrains.org.objectweb.asm.commons.Method; -import java.util.Collection; -import java.util.Collections; -import java.util.LinkedHashSet; -import java.util.List; +import java.util.*; import static org.jetbrains.kotlin.codegen.AsmUtil.calculateInnerClassAccessFlags; import static org.jetbrains.kotlin.codegen.AsmUtil.isPrimitive; @@ -739,13 +737,26 @@ public abstract class MemberCodegen accessorsForCompanionObjects = + context.getRequiredAccessorsForCompanionObjects(); + if (!accessorsForCompanionObjects.isEmpty()) { + List sortedAccessorsForCompanionObjects = + new ArrayList<>(accessorsForCompanionObjects); + sortedAccessorsForCompanionObjects.sort(BY_COMPANION_FQN); + + for (AccessorForCompanionObjectInstanceFieldDescriptor accessor : sortedAccessorsForCompanionObjects) { + generateSyntheticAccessorForCompanionObject(accessor); + } } } + private final Comparator BY_COMPANION_FQN = + (o1, o2) -> { + String companionFQN1 = DescriptorUtils.getFqName(o1.getCompanionObjectDescriptor()).asString(); + String companionFQN2 = DescriptorUtils.getFqName(o2.getCompanionObjectDescriptor()).asString(); + return companionFQN1.compareTo(companionFQN2); + }; + private void generateSyntheticAccessorForCompanionObject(@NotNull AccessorForCompanionObjectInstanceFieldDescriptor accessor) { ClassDescriptor companionObjectDescriptor = accessor.getCompanionObjectDescriptor(); DeclarationDescriptor hostClassDescriptor = companionObjectDescriptor.getContainingDeclaration(); diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/context/CodegenContext.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/context/CodegenContext.java index d16937c220d..9fd7eceed59 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/context/CodegenContext.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/context/CodegenContext.java @@ -26,6 +26,7 @@ import org.jetbrains.org.objectweb.asm.Type; import java.util.*; import static org.jetbrains.kotlin.codegen.AsmUtil.getVisibilityAccessFlag; +import static org.jetbrains.kotlin.codegen.JvmCodegenUtil.isInSamePackage; import static org.jetbrains.kotlin.codegen.JvmCodegenUtil.isNonDefaultInterfaceMember; import static org.jetbrains.kotlin.resolve.inline.InlineOnlyKt.isInlineOnlyPrivateInBytecode; import static org.jetbrains.kotlin.resolve.jvm.annotations.JvmAnnotationUtilKt.hasJvmDefaultAnnotation; @@ -33,6 +34,7 @@ import static org.jetbrains.kotlin.resolve.jvm.annotations.JvmAnnotationUtilKt.i import static org.jetbrains.org.objectweb.asm.Opcodes.ACC_PRIVATE; import static org.jetbrains.org.objectweb.asm.Opcodes.ACC_PROTECTED; +@SuppressWarnings("rawtypes") public abstract class CodegenContext { private final T contextDescriptor; private final OwnerKind contextKind; @@ -45,7 +47,8 @@ public abstract class CodegenContext { private Map childContexts; private Map> accessors; private Map propertyAccessorFactories; - private AccessorForCompanionObjectInstanceFieldDescriptor accessorForCompanionObjectInstanceFieldDescriptor = null; + private final Map accessorsForCompanionObjects = + new LinkedHashMap<>(); private static class AccessorKey { public final DeclarationDescriptor descriptor; @@ -67,8 +70,7 @@ public abstract class CodegenContext { AccessorKey other = (AccessorKey) obj; return descriptor.equals(other.descriptor) && accessorKind == other.accessorKind && - (superCallLabelTarget == null ? other.superCallLabelTarget == null - : superCallLabelTarget.equals(other.superCallLabelTarget)); + Objects.equals(superCallLabelTarget, other.superCallLabelTarget); } @Override @@ -701,16 +703,6 @@ public abstract class CodegenContext { (withinInline || !isInSamePackage(unwrappedDescriptor, descriptorContext.getContextDescriptor()))); } - private static boolean isInSamePackage(DeclarationDescriptor descriptor1, DeclarationDescriptor descriptor2) { - PackageFragmentDescriptor package1 = - DescriptorUtils.getParentOfType(descriptor1, PackageFragmentDescriptor.class, false); - PackageFragmentDescriptor package2 = - DescriptorUtils.getParentOfType(descriptor2, PackageFragmentDescriptor.class, false); - - return package2 != null && package1 != null && - package1.getFqName().equals(package2.getFqName()); - } - private void addChild(@NotNull CodegenContext child) { if (shouldAddChild(child.contextDescriptor)) { if (childContexts == null) { @@ -748,29 +740,23 @@ public abstract class CodegenContext { return enclosingLocalLookup; } + @SuppressWarnings("UnusedReturnValue") @NotNull - public AccessorForCompanionObjectInstanceFieldDescriptor markCompanionObjectDescriptorWithAccessorRequired(@NotNull ClassDescriptor companionObjectDescriptor) { - assert DescriptorUtils.isCompanionObject(companionObjectDescriptor) : "Companion object expected: " + companionObjectDescriptor; - - assert accessorForCompanionObjectInstanceFieldDescriptor == null - || accessorForCompanionObjectInstanceFieldDescriptor.getCompanionObjectDescriptor() == companionObjectDescriptor - : "Unexpected companion object descriptor with accessor required: " + companionObjectDescriptor + - "; should be " + accessorForCompanionObjectInstanceFieldDescriptor.getCompanionObjectDescriptor(); - - if (accessorForCompanionObjectInstanceFieldDescriptor == null) { - accessorForCompanionObjectInstanceFieldDescriptor = - new AccessorForCompanionObjectInstanceFieldDescriptor( - companionObjectDescriptor, - Name.identifier(JvmCodegenUtil.getCompanionObjectAccessorName(companionObjectDescriptor)) - ); - } - - return accessorForCompanionObjectInstanceFieldDescriptor; + public AccessorForCompanionObjectInstanceFieldDescriptor getOrCreateAccessorForCompanionObject( + @NotNull ClassDescriptor companionObjectDescriptor + ) { + return accessorsForCompanionObjects.computeIfAbsent( + companionObjectDescriptor, + it -> new AccessorForCompanionObjectInstanceFieldDescriptor( + it, + Name.identifier(JvmCodegenUtil.getCompanionObjectAccessorName(it)) + ) + ); } - @Nullable - public AccessorForCompanionObjectInstanceFieldDescriptor getAccessorForCompanionObjectDescriptorIfRequired() { - return accessorForCompanionObjectInstanceFieldDescriptor; + @NotNull + public Collection getRequiredAccessorsForCompanionObjects() { + return accessorsForCompanionObjects.values(); } } diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/context/MethodContext.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/context/MethodContext.java index 9b898469910..17b7f9b91c0 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/context/MethodContext.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/context/MethodContext.java @@ -123,6 +123,7 @@ public class MethodContext extends CodegenContext { return "Method: " + getContextDescriptor(); } + @Override public boolean isInlineMethodContext() { return InlineUtil.isInline(getFunctionDescriptor()); } diff --git a/compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/accessFromInlineLambda.kt b/compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/accessFromInlineLambda.kt new file mode 100644 index 00000000000..c9cfbb185da --- /dev/null +++ b/compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/accessFromInlineLambda.kt @@ -0,0 +1,37 @@ +// !LANGUAGE: +ProperVisibilityForCompanionObjectInstanceField +// IGNORE_BACKEND_FIR: JVM_IR +// FILE: accessFromInlineLambda.kt +import c.C + +fun box() = C().test() + +// FILE: a.kt +package a + +open class A { + protected companion object { + fun getO() = "O" + } +} + +// FILE: b.kt +package b + +import a.A + +open class B : A() { + protected companion object { + fun getK() = "K" + } +} + +// FILE: c.kt +package c + +import b.B + +inline fun runStr(fn: () -> String) = fn() + +class C : B() { + val test = { runStr { getO() + getK() } } +} diff --git a/compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/anonymousObjectInPropertyInitializer.kt b/compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/anonymousObjectInPropertyInitializer.kt new file mode 100644 index 00000000000..d5eb51c8f09 --- /dev/null +++ b/compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/anonymousObjectInPropertyInitializer.kt @@ -0,0 +1,37 @@ +// !LANGUAGE: +ProperVisibilityForCompanionObjectInstanceField +// IGNORE_BACKEND_FIR: JVM_IR +// FILE: anonymousObjectInPropertyInitializer.kt +import c.C + +fun box() = C().test.toString() + +// FILE: a.kt +package a + +open class A { + protected companion object { + fun getO() = "O" + } +} + +// FILE: b.kt +package b + +import a.A + +open class B : A() { + protected companion object { + fun getK() = "K" + } +} + +// FILE: c.kt +package c + +import b.B + +class C { + val test = object : B() { + override fun toString() = getO() + getK() + } +} diff --git a/compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/fromAnonymousObjectInNestedClass.kt b/compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/fromAnonymousObjectInNestedClass.kt new file mode 100644 index 00000000000..f3266d6c146 --- /dev/null +++ b/compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/fromAnonymousObjectInNestedClass.kt @@ -0,0 +1,34 @@ +// !LANGUAGE: +ProperVisibilityForCompanionObjectInstanceField +// IGNORE_BACKEND_FIR: JVM_IR +// FILE: fromAnonymousObjectInNestedClass.kt +import outer.* + +fun box() = Outer().test() + +// FILE: Outer.kt +package outer + +import a.A + +class Outer : A() { + private companion object { + fun getK() = "K" + } + + class Nested { + fun foo() = object { + override fun toString() = getO() + getK() + } + } + + fun test() = Nested().foo().toString() +} + +// FILE: a.kt +package a + +open class A { + protected companion object { + fun getO() = "O" + } +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/fromInitBlock.kt b/compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/fromInitBlock.kt new file mode 100644 index 00000000000..efeebc4d53f --- /dev/null +++ b/compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/fromInitBlock.kt @@ -0,0 +1,31 @@ +// !LANGUAGE: +ProperVisibilityForCompanionObjectInstanceField +// FILE: fromInitBlock.kt +import outer.* + +fun box() = Outer().test + +// FILE: Outer.kt +package outer + +import a.* + +class Outer : A() { + private companion object { + fun getK() = "K" + } + + val test: String + + init { + test = getO() + getK() + } +} + +// FILE: a.kt +package a + +open class A { + protected companion object { + fun getO() = "O" + } +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/fromInitBlockOfNestedClass.kt b/compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/fromInitBlockOfNestedClass.kt new file mode 100644 index 00000000000..41bd2ae5259 --- /dev/null +++ b/compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/fromInitBlockOfNestedClass.kt @@ -0,0 +1,33 @@ +// !LANGUAGE: +ProperVisibilityForCompanionObjectInstanceField +// FILE: fromInitBlockOfNestedClass.kt +import b.* + +fun box() = Outer.Nested().test + +// FILE: b.kt +package b + +import a.* + +class Outer : A() { + private companion object { + fun getK() = "K" + } + + class Nested { + val test: String + + init { + test = getO() + getK() + } + } +} + +// FILE: a.kt +package a + +open class A { + protected companion object { + fun getO() = "O" + } +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/fromInlineLambdaInNestedClass.kt b/compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/fromInlineLambdaInNestedClass.kt new file mode 100644 index 00000000000..2361af88ee7 --- /dev/null +++ b/compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/fromInlineLambdaInNestedClass.kt @@ -0,0 +1,35 @@ +// !LANGUAGE: +ProperVisibilityForCompanionObjectInstanceField +// IGNORE_BACKEND_FIR: JVM_IR +// FILE: fromInlineLambdaInNestedClass.kt +import b.* + +fun box() = Outer().test() + +// FILE: a.kt +package a + +open class A { + protected companion object { + val vo = "O" + } +} + +// FILE: b.kt +package b + +import a.* + +inline fun run(fn: () -> T) = fn() + +class Outer : A() { + private companion object { + val vk = "K" + } + + class Nested { + fun foo() = run { vo + vk } + } + + fun test() = Nested().foo() +} + diff --git a/compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/inheritedProtectedCompanionAndOwnPrivateCompanion.kt b/compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/inheritedProtectedCompanionAndOwnPrivateCompanion.kt new file mode 100644 index 00000000000..677bc51664a --- /dev/null +++ b/compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/inheritedProtectedCompanionAndOwnPrivateCompanion.kt @@ -0,0 +1,28 @@ +// !LANGUAGE: +ProperVisibilityForCompanionObjectInstanceField +// IGNORE_BACKEND_FIR: JVM_IR +// FILE: inheritedProtectedCompanionAndOwnPrivateCompanion.kt +import b.B + +fun box() = B().test()() + +// FILE: a.kt +package a + +open class A { + protected companion object { + fun getO() = "O" + } +} + +// FILE: b.kt +package b + +import a.A + +class B : A() { + fun test() = { getO() + getK() } + + private companion object { + fun getK() = "K" + } +} diff --git a/compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/inheritedProtectedCompanionsReferencedByName.kt b/compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/inheritedProtectedCompanionsReferencedByName.kt new file mode 100644 index 00000000000..982d08f62d1 --- /dev/null +++ b/compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/inheritedProtectedCompanionsReferencedByName.kt @@ -0,0 +1,36 @@ +// !LANGUAGE: +ProperVisibilityForCompanionObjectInstanceField +// IGNORE_BACKEND_FIR: JVM_IR +// FILE: twoInheritedProtectedCompanions.kt +import c.C + +fun box() = C().test()() + +// FILE: a.kt +package a + +open class A { + protected companion object AC { + fun getO() = "O" + } +} + +// FILE: b.kt +package b + +import a.A + +open class B : A() { + protected companion object BC { + fun getK() = "K" + } +} + +// FILE: c.kt +package c + +import a.A +import b.B + +class C : B() { + fun test() = { A.AC.getO() + B.BC.getK() } +} diff --git a/compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/lambdaInPropertyInitializer.kt b/compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/lambdaInPropertyInitializer.kt new file mode 100644 index 00000000000..75736d2d435 --- /dev/null +++ b/compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/lambdaInPropertyInitializer.kt @@ -0,0 +1,35 @@ +// !LANGUAGE: +ProperVisibilityForCompanionObjectInstanceField +// IGNORE_BACKEND_FIR: JVM_IR +// FILE: lambdaInPropertyInitializer.kt +import c.C + +fun box() = C().test() + +// FILE: a.kt +package a + +open class A { + protected companion object { + fun getO() = "O" + } +} + +// FILE: b.kt +package b + +import a.A + +open class B : A() { + protected companion object { + fun getK() = "K" + } +} + +// FILE: c.kt +package c + +import b.B + +class C : B() { + val test = { getO() + getK() } +} diff --git a/compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/twoInheritedProtectedCompanions.kt b/compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/twoInheritedProtectedCompanions.kt new file mode 100644 index 00000000000..20b6ba5a9eb --- /dev/null +++ b/compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/twoInheritedProtectedCompanions.kt @@ -0,0 +1,35 @@ +// !LANGUAGE: +ProperVisibilityForCompanionObjectInstanceField +// IGNORE_BACKEND_FIR: JVM_IR +// FILE: twoInheritedProtectedCompanions.kt +import c.C + +fun box() = C().test()() + +// FILE: a.kt +package a + +open class A { + protected companion object { + fun getO() = "O" + } +} + +// FILE: b.kt +package b + +import a.A + +open class B : A() { + protected companion object { + fun getK() = "K" + } +} + +// FILE: c.kt +package c + +import b.B + +class C : B() { + fun test() = { getO() + getK() } +} diff --git a/compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/withCompanionObjectBase.kt b/compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/withCompanionObjectBase.kt new file mode 100644 index 00000000000..025123b2027 --- /dev/null +++ b/compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/withCompanionObjectBase.kt @@ -0,0 +1,26 @@ +// !LANGUAGE: +ProperVisibilityForCompanionObjectInstanceField +// IGNORE_BACKEND_FIR: JVM_IR +// FILE: withCompanionObjectBase.kt +import b.* + +fun box() = B.ok + +// FILE: a.kt +package a + +open class A { + protected companion object { + fun getOK() = "OK" + } +} + +// FILE: b.kt +package b + +import a.* + +class B { + companion object : A() { + val ok = getOK() + } +} diff --git a/compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/withMultipleNestedCompanionObjectBases.kt b/compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/withMultipleNestedCompanionObjectBases.kt new file mode 100644 index 00000000000..36b6b3b0999 --- /dev/null +++ b/compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/withMultipleNestedCompanionObjectBases.kt @@ -0,0 +1,44 @@ +// !LANGUAGE: +ProperVisibilityForCompanionObjectInstanceField +// IGNORE_BACKEND_FIR: JVM_IR +// FILE: withCompanionObjectBase.kt +import b.* + +fun box() = B.vok + +// FILE: a.kt +package a + +open class A1 { + protected companion object { + fun getO() = "O" + } +} + +open class A2 { + protected companion object { + fun getK() = "K" + } +} + +// FILE: b.kt +package b + +import a.* + +class B { + class B1 { + companion object : A1() { + val vo = getO() + } + + class B2 { + companion object : A2() { + val vk = getK() + } + } + } + + companion object { + val vok = B1.vo + B1.B2.vk + } +} diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/BlackBoxCodegenTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/codegen/BlackBoxCodegenTestGenerated.java index 20649585a75..5943b3aa715 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/BlackBoxCodegenTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/BlackBoxCodegenTestGenerated.java @@ -17642,6 +17642,79 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { runTest("compiler/testData/codegen/box/objects/companionObjectAccess/protectedCompanionObjectAccessedFromNestedClass.kt"); } + @TestMetadata("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class MultipleCompanionsWithAccessors extends AbstractBlackBoxCodegenTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath); + } + + @TestMetadata("accessFromInlineLambda.kt") + public void testAccessFromInlineLambda() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/accessFromInlineLambda.kt"); + } + + public void testAllFilesPresentInMultipleCompanionsWithAccessors() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + } + + @TestMetadata("anonymousObjectInPropertyInitializer.kt") + public void testAnonymousObjectInPropertyInitializer() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/anonymousObjectInPropertyInitializer.kt"); + } + + @TestMetadata("fromAnonymousObjectInNestedClass.kt") + public void testFromAnonymousObjectInNestedClass() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/fromAnonymousObjectInNestedClass.kt"); + } + + @TestMetadata("fromInitBlock.kt") + public void testFromInitBlock() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/fromInitBlock.kt"); + } + + @TestMetadata("fromInitBlockOfNestedClass.kt") + public void testFromInitBlockOfNestedClass() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/fromInitBlockOfNestedClass.kt"); + } + + @TestMetadata("fromInlineLambdaInNestedClass.kt") + public void testFromInlineLambdaInNestedClass() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/fromInlineLambdaInNestedClass.kt"); + } + + @TestMetadata("inheritedProtectedCompanionAndOwnPrivateCompanion.kt") + public void testInheritedProtectedCompanionAndOwnPrivateCompanion() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/inheritedProtectedCompanionAndOwnPrivateCompanion.kt"); + } + + @TestMetadata("inheritedProtectedCompanionsReferencedByName.kt") + public void testInheritedProtectedCompanionsReferencedByName() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/inheritedProtectedCompanionsReferencedByName.kt"); + } + + @TestMetadata("lambdaInPropertyInitializer.kt") + public void testLambdaInPropertyInitializer() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/lambdaInPropertyInitializer.kt"); + } + + @TestMetadata("twoInheritedProtectedCompanions.kt") + public void testTwoInheritedProtectedCompanions() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/twoInheritedProtectedCompanions.kt"); + } + + @TestMetadata("withCompanionObjectBase.kt") + public void testWithCompanionObjectBase() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/withCompanionObjectBase.kt"); + } + + @TestMetadata("withMultipleNestedCompanionObjectBases.kt") + public void testWithMultipleNestedCompanionObjectBases() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/withMultipleNestedCompanionObjectBases.kt"); + } + } + @TestMetadata("compiler/testData/codegen/box/objects/companionObjectAccess/primitiveCompanion") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java index 33690bedd7e..1bf48f9292d 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java @@ -17642,6 +17642,79 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes runTest("compiler/testData/codegen/box/objects/companionObjectAccess/protectedCompanionObjectAccessedFromNestedClass.kt"); } + @TestMetadata("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class MultipleCompanionsWithAccessors extends AbstractLightAnalysisModeTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath); + } + + @TestMetadata("accessFromInlineLambda.kt") + public void testAccessFromInlineLambda() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/accessFromInlineLambda.kt"); + } + + public void testAllFilesPresentInMultipleCompanionsWithAccessors() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + } + + @TestMetadata("anonymousObjectInPropertyInitializer.kt") + public void testAnonymousObjectInPropertyInitializer() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/anonymousObjectInPropertyInitializer.kt"); + } + + @TestMetadata("fromAnonymousObjectInNestedClass.kt") + public void testFromAnonymousObjectInNestedClass() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/fromAnonymousObjectInNestedClass.kt"); + } + + @TestMetadata("fromInitBlock.kt") + public void testFromInitBlock() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/fromInitBlock.kt"); + } + + @TestMetadata("fromInitBlockOfNestedClass.kt") + public void testFromInitBlockOfNestedClass() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/fromInitBlockOfNestedClass.kt"); + } + + @TestMetadata("fromInlineLambdaInNestedClass.kt") + public void testFromInlineLambdaInNestedClass() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/fromInlineLambdaInNestedClass.kt"); + } + + @TestMetadata("inheritedProtectedCompanionAndOwnPrivateCompanion.kt") + public void testInheritedProtectedCompanionAndOwnPrivateCompanion() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/inheritedProtectedCompanionAndOwnPrivateCompanion.kt"); + } + + @TestMetadata("inheritedProtectedCompanionsReferencedByName.kt") + public void testInheritedProtectedCompanionsReferencedByName() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/inheritedProtectedCompanionsReferencedByName.kt"); + } + + @TestMetadata("lambdaInPropertyInitializer.kt") + public void testLambdaInPropertyInitializer() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/lambdaInPropertyInitializer.kt"); + } + + @TestMetadata("twoInheritedProtectedCompanions.kt") + public void testTwoInheritedProtectedCompanions() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/twoInheritedProtectedCompanions.kt"); + } + + @TestMetadata("withCompanionObjectBase.kt") + public void testWithCompanionObjectBase() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/withCompanionObjectBase.kt"); + } + + @TestMetadata("withMultipleNestedCompanionObjectBases.kt") + public void testWithMultipleNestedCompanionObjectBases() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/withMultipleNestedCompanionObjectBases.kt"); + } + } + @TestMetadata("compiler/testData/codegen/box/objects/companionObjectAccess/primitiveCompanion") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/ir/FirBlackBoxCodegenTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/codegen/ir/FirBlackBoxCodegenTestGenerated.java index 5ecfc6f4702..a499c3e3d7e 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/ir/FirBlackBoxCodegenTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/ir/FirBlackBoxCodegenTestGenerated.java @@ -16492,6 +16492,79 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT runTest("compiler/testData/codegen/box/objects/companionObjectAccess/protectedCompanionObjectAccessedFromNestedClass.kt"); } + @TestMetadata("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class MultipleCompanionsWithAccessors extends AbstractFirBlackBoxCodegenTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_IR, testDataFilePath, "// IGNORE_BACKEND_FIR: "); + } + + @TestMetadata("accessFromInlineLambda.kt") + public void testAccessFromInlineLambda() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/accessFromInlineLambda.kt"); + } + + public void testAllFilesPresentInMultipleCompanionsWithAccessors() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @TestMetadata("anonymousObjectInPropertyInitializer.kt") + public void testAnonymousObjectInPropertyInitializer() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/anonymousObjectInPropertyInitializer.kt"); + } + + @TestMetadata("fromAnonymousObjectInNestedClass.kt") + public void testFromAnonymousObjectInNestedClass() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/fromAnonymousObjectInNestedClass.kt"); + } + + @TestMetadata("fromInitBlock.kt") + public void testFromInitBlock() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/fromInitBlock.kt"); + } + + @TestMetadata("fromInitBlockOfNestedClass.kt") + public void testFromInitBlockOfNestedClass() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/fromInitBlockOfNestedClass.kt"); + } + + @TestMetadata("fromInlineLambdaInNestedClass.kt") + public void testFromInlineLambdaInNestedClass() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/fromInlineLambdaInNestedClass.kt"); + } + + @TestMetadata("inheritedProtectedCompanionAndOwnPrivateCompanion.kt") + public void testInheritedProtectedCompanionAndOwnPrivateCompanion() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/inheritedProtectedCompanionAndOwnPrivateCompanion.kt"); + } + + @TestMetadata("inheritedProtectedCompanionsReferencedByName.kt") + public void testInheritedProtectedCompanionsReferencedByName() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/inheritedProtectedCompanionsReferencedByName.kt"); + } + + @TestMetadata("lambdaInPropertyInitializer.kt") + public void testLambdaInPropertyInitializer() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/lambdaInPropertyInitializer.kt"); + } + + @TestMetadata("twoInheritedProtectedCompanions.kt") + public void testTwoInheritedProtectedCompanions() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/twoInheritedProtectedCompanions.kt"); + } + + @TestMetadata("withCompanionObjectBase.kt") + public void testWithCompanionObjectBase() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/withCompanionObjectBase.kt"); + } + + @TestMetadata("withMultipleNestedCompanionObjectBases.kt") + public void testWithMultipleNestedCompanionObjectBases() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/withMultipleNestedCompanionObjectBases.kt"); + } + } + @TestMetadata("compiler/testData/codegen/box/objects/companionObjectAccess/primitiveCompanion") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/ir/IrBlackBoxCodegenTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/codegen/ir/IrBlackBoxCodegenTestGenerated.java index 833328084a2..6e56abdea8a 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/ir/IrBlackBoxCodegenTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/ir/IrBlackBoxCodegenTestGenerated.java @@ -16492,6 +16492,79 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes runTest("compiler/testData/codegen/box/objects/companionObjectAccess/protectedCompanionObjectAccessedFromNestedClass.kt"); } + @TestMetadata("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class MultipleCompanionsWithAccessors extends AbstractIrBlackBoxCodegenTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + @TestMetadata("accessFromInlineLambda.kt") + public void testAccessFromInlineLambda() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/accessFromInlineLambda.kt"); + } + + public void testAllFilesPresentInMultipleCompanionsWithAccessors() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @TestMetadata("anonymousObjectInPropertyInitializer.kt") + public void testAnonymousObjectInPropertyInitializer() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/anonymousObjectInPropertyInitializer.kt"); + } + + @TestMetadata("fromAnonymousObjectInNestedClass.kt") + public void testFromAnonymousObjectInNestedClass() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/fromAnonymousObjectInNestedClass.kt"); + } + + @TestMetadata("fromInitBlock.kt") + public void testFromInitBlock() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/fromInitBlock.kt"); + } + + @TestMetadata("fromInitBlockOfNestedClass.kt") + public void testFromInitBlockOfNestedClass() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/fromInitBlockOfNestedClass.kt"); + } + + @TestMetadata("fromInlineLambdaInNestedClass.kt") + public void testFromInlineLambdaInNestedClass() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/fromInlineLambdaInNestedClass.kt"); + } + + @TestMetadata("inheritedProtectedCompanionAndOwnPrivateCompanion.kt") + public void testInheritedProtectedCompanionAndOwnPrivateCompanion() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/inheritedProtectedCompanionAndOwnPrivateCompanion.kt"); + } + + @TestMetadata("inheritedProtectedCompanionsReferencedByName.kt") + public void testInheritedProtectedCompanionsReferencedByName() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/inheritedProtectedCompanionsReferencedByName.kt"); + } + + @TestMetadata("lambdaInPropertyInitializer.kt") + public void testLambdaInPropertyInitializer() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/lambdaInPropertyInitializer.kt"); + } + + @TestMetadata("twoInheritedProtectedCompanions.kt") + public void testTwoInheritedProtectedCompanions() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/twoInheritedProtectedCompanions.kt"); + } + + @TestMetadata("withCompanionObjectBase.kt") + public void testWithCompanionObjectBase() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/withCompanionObjectBase.kt"); + } + + @TestMetadata("withMultipleNestedCompanionObjectBases.kt") + public void testWithMultipleNestedCompanionObjectBases() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/withMultipleNestedCompanionObjectBases.kt"); + } + } + @TestMetadata("compiler/testData/codegen/box/objects/companionObjectAccess/primitiveCompanion") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) diff --git a/js/js.tests/test/org/jetbrains/kotlin/js/test/ir/semantics/IrJsCodegenBoxTestGenerated.java b/js/js.tests/test/org/jetbrains/kotlin/js/test/ir/semantics/IrJsCodegenBoxTestGenerated.java index 475adbebe8e..7d209855d43 100644 --- a/js/js.tests/test/org/jetbrains/kotlin/js/test/ir/semantics/IrJsCodegenBoxTestGenerated.java +++ b/js/js.tests/test/org/jetbrains/kotlin/js/test/ir/semantics/IrJsCodegenBoxTestGenerated.java @@ -13512,6 +13512,79 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { runTest("compiler/testData/codegen/box/objects/companionObjectAccess/protectedCompanionObjectAccessedFromNestedClass.kt"); } + @TestMetadata("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class MultipleCompanionsWithAccessors extends AbstractIrJsCodegenBoxTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest0(this::doTest, TargetBackend.JS_IR, testDataFilePath); + } + + @TestMetadata("accessFromInlineLambda.kt") + public void testAccessFromInlineLambda() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/accessFromInlineLambda.kt"); + } + + public void testAllFilesPresentInMultipleCompanionsWithAccessors() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + } + + @TestMetadata("anonymousObjectInPropertyInitializer.kt") + public void testAnonymousObjectInPropertyInitializer() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/anonymousObjectInPropertyInitializer.kt"); + } + + @TestMetadata("fromAnonymousObjectInNestedClass.kt") + public void testFromAnonymousObjectInNestedClass() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/fromAnonymousObjectInNestedClass.kt"); + } + + @TestMetadata("fromInitBlock.kt") + public void testFromInitBlock() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/fromInitBlock.kt"); + } + + @TestMetadata("fromInitBlockOfNestedClass.kt") + public void testFromInitBlockOfNestedClass() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/fromInitBlockOfNestedClass.kt"); + } + + @TestMetadata("fromInlineLambdaInNestedClass.kt") + public void testFromInlineLambdaInNestedClass() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/fromInlineLambdaInNestedClass.kt"); + } + + @TestMetadata("inheritedProtectedCompanionAndOwnPrivateCompanion.kt") + public void testInheritedProtectedCompanionAndOwnPrivateCompanion() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/inheritedProtectedCompanionAndOwnPrivateCompanion.kt"); + } + + @TestMetadata("inheritedProtectedCompanionsReferencedByName.kt") + public void testInheritedProtectedCompanionsReferencedByName() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/inheritedProtectedCompanionsReferencedByName.kt"); + } + + @TestMetadata("lambdaInPropertyInitializer.kt") + public void testLambdaInPropertyInitializer() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/lambdaInPropertyInitializer.kt"); + } + + @TestMetadata("twoInheritedProtectedCompanions.kt") + public void testTwoInheritedProtectedCompanions() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/twoInheritedProtectedCompanions.kt"); + } + + @TestMetadata("withCompanionObjectBase.kt") + public void testWithCompanionObjectBase() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/withCompanionObjectBase.kt"); + } + + @TestMetadata("withMultipleNestedCompanionObjectBases.kt") + public void testWithMultipleNestedCompanionObjectBases() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/withMultipleNestedCompanionObjectBases.kt"); + } + } + @TestMetadata("compiler/testData/codegen/box/objects/companionObjectAccess/primitiveCompanion") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) diff --git a/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/JsCodegenBoxTestGenerated.java b/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/JsCodegenBoxTestGenerated.java index 7242c64ee52..d95e57118fd 100644 --- a/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/JsCodegenBoxTestGenerated.java +++ b/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/JsCodegenBoxTestGenerated.java @@ -14652,6 +14652,79 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { runTest("compiler/testData/codegen/box/objects/companionObjectAccess/protectedCompanionObjectAccessedFromNestedClass.kt"); } + @TestMetadata("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class MultipleCompanionsWithAccessors extends AbstractJsCodegenBoxTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest0(this::doTest, TargetBackend.JS, testDataFilePath); + } + + @TestMetadata("accessFromInlineLambda.kt") + public void testAccessFromInlineLambda() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/accessFromInlineLambda.kt"); + } + + public void testAllFilesPresentInMultipleCompanionsWithAccessors() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + } + + @TestMetadata("anonymousObjectInPropertyInitializer.kt") + public void testAnonymousObjectInPropertyInitializer() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/anonymousObjectInPropertyInitializer.kt"); + } + + @TestMetadata("fromAnonymousObjectInNestedClass.kt") + public void testFromAnonymousObjectInNestedClass() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/fromAnonymousObjectInNestedClass.kt"); + } + + @TestMetadata("fromInitBlock.kt") + public void testFromInitBlock() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/fromInitBlock.kt"); + } + + @TestMetadata("fromInitBlockOfNestedClass.kt") + public void testFromInitBlockOfNestedClass() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/fromInitBlockOfNestedClass.kt"); + } + + @TestMetadata("fromInlineLambdaInNestedClass.kt") + public void testFromInlineLambdaInNestedClass() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/fromInlineLambdaInNestedClass.kt"); + } + + @TestMetadata("inheritedProtectedCompanionAndOwnPrivateCompanion.kt") + public void testInheritedProtectedCompanionAndOwnPrivateCompanion() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/inheritedProtectedCompanionAndOwnPrivateCompanion.kt"); + } + + @TestMetadata("inheritedProtectedCompanionsReferencedByName.kt") + public void testInheritedProtectedCompanionsReferencedByName() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/inheritedProtectedCompanionsReferencedByName.kt"); + } + + @TestMetadata("lambdaInPropertyInitializer.kt") + public void testLambdaInPropertyInitializer() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/lambdaInPropertyInitializer.kt"); + } + + @TestMetadata("twoInheritedProtectedCompanions.kt") + public void testTwoInheritedProtectedCompanions() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/twoInheritedProtectedCompanions.kt"); + } + + @TestMetadata("withCompanionObjectBase.kt") + public void testWithCompanionObjectBase() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/withCompanionObjectBase.kt"); + } + + @TestMetadata("withMultipleNestedCompanionObjectBases.kt") + public void testWithMultipleNestedCompanionObjectBases() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/withMultipleNestedCompanionObjectBases.kt"); + } + } + @TestMetadata("compiler/testData/codegen/box/objects/companionObjectAccess/primitiveCompanion") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class)