diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/AccessorForConstructorDescriptor.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/AccessorForConstructorDescriptor.kt index e124529ab2c..697cd13b2a1 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/AccessorForConstructorDescriptor.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/AccessorForConstructorDescriptor.kt @@ -47,7 +47,7 @@ public class AccessorForConstructorDescriptor( copyValueParameters(calleeDescriptor), calleeDescriptor.returnType, Modality.FINAL, - Visibilities.INTERNAL, + Visibilities.LOCAL, false, false ) diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/AccessorForFunctionDescriptor.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/AccessorForFunctionDescriptor.java index 9bba978bb7c..9e3e6e346a4 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/AccessorForFunctionDescriptor.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/AccessorForFunctionDescriptor.java @@ -47,7 +47,7 @@ public class AccessorForFunctionDescriptor extends AbstractAccessorForFunctionDe copyValueParameters(descriptor), descriptor.getReturnType(), Modality.FINAL, - Visibilities.INTERNAL, + Visibilities.LOCAL, descriptor.isOperator(), descriptor.isInfix()); } diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java index 63303aa6331..2c19a51bb64 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java @@ -2234,14 +2234,7 @@ public class ExpressionCodegen extends JetVisitor implem fieldName = ((FieldOwnerContext) backingFieldContext).getFieldName(propertyDescriptor, isDelegatedProperty); } else { - Name name; - if (propertyDescriptor instanceof AccessorForPropertyDescriptor) { - name = ((AccessorForPropertyDescriptor) propertyDescriptor).getCalleeDescriptor().getName(); - } - else { - name = propertyDescriptor.getName(); - } - fieldName = JvmAbi.getDefaultFieldNameForProperty(name, isDelegatedProperty); + fieldName = JetTypeMapper.mapDefaultFieldName(propertyDescriptor, isDelegatedProperty); } return StackValue.property(propertyDescriptor, backingFieldOwner, diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/JvmCodegenUtil.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/JvmCodegenUtil.java index c323f7d8813..cf939a95b30 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/JvmCodegenUtil.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/JvmCodegenUtil.java @@ -33,6 +33,7 @@ import org.jetbrains.kotlin.load.java.JvmAnnotationNames; import org.jetbrains.kotlin.load.java.descriptors.JavaClassDescriptor; import org.jetbrains.kotlin.load.kotlin.ModuleMapping; import org.jetbrains.kotlin.load.kotlin.ModuleVisibilityUtilsKt; +import org.jetbrains.kotlin.load.kotlin.PackagePartClassUtils; import org.jetbrains.kotlin.load.kotlin.incremental.IncrementalPackageFragmentProvider; import org.jetbrains.kotlin.psi.JetFile; import org.jetbrains.kotlin.psi.JetFunction; @@ -233,4 +234,9 @@ public class JvmCodegenUtil { // TODO: drop after some time av.visit(JvmAnnotationNames.OLD_ABI_VERSION_FIELD_NAME, JvmAbi.VERSION.getMinor()); } + + @NotNull + public static String sanitizeAsJavaIdentifier(@NotNull String str) { + return PackagePartClassUtils.sanitizeAsJavaIdentifier(str); + } } diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/context/FieldOwnerContext.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/context/FieldOwnerContext.java index 948a5c2700b..4ad9d01c377 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/context/FieldOwnerContext.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/context/FieldOwnerContext.java @@ -18,12 +18,13 @@ package org.jetbrains.kotlin.codegen.context; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; +import org.jetbrains.kotlin.codegen.AccessorForPropertyDescriptor; import org.jetbrains.kotlin.codegen.OwnerKind; import org.jetbrains.kotlin.codegen.binding.MutableClosure; +import org.jetbrains.kotlin.codegen.state.JetTypeMapper; import org.jetbrains.kotlin.descriptors.ClassDescriptor; import org.jetbrains.kotlin.descriptors.DeclarationDescriptor; import org.jetbrains.kotlin.descriptors.PropertyDescriptor; -import org.jetbrains.kotlin.load.java.JvmAbi; import java.util.HashMap; import java.util.Map; @@ -45,10 +46,14 @@ public abstract class FieldOwnerContext extends @NotNull public String getFieldName(@NotNull PropertyDescriptor possiblySubstitutedDescriptor, boolean isDelegated) { + if (possiblySubstitutedDescriptor instanceof AccessorForPropertyDescriptor) { + possiblySubstitutedDescriptor = ((AccessorForPropertyDescriptor) possiblySubstitutedDescriptor).getCalleeDescriptor(); + } + PropertyDescriptor descriptor = possiblySubstitutedDescriptor.getOriginal(); assert descriptor.getKind().isReal() : "Only declared properties can have backing fields: " + descriptor; - String defaultPropertyName = JvmAbi.getDefaultFieldNameForProperty(descriptor.getName(), isDelegated); + String defaultPropertyName = JetTypeMapper.mapDefaultFieldName(descriptor, isDelegated); Map descriptor2Name = fieldNames.get(defaultPropertyName); if (descriptor2Name == null) { diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/signature/KotlinToJvmSignatureMapperImpl.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/signature/KotlinToJvmSignatureMapperImpl.kt index 2275b771d6a..faecf8faacb 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/signature/KotlinToJvmSignatureMapperImpl.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/signature/KotlinToJvmSignatureMapperImpl.kt @@ -20,13 +20,13 @@ import org.jetbrains.kotlin.codegen.ClassBuilderMode import org.jetbrains.kotlin.codegen.state.JetTypeMapper import org.jetbrains.kotlin.descriptors.FunctionDescriptor import org.jetbrains.kotlin.fileClasses.NoResolveFileClassesProvider +import org.jetbrains.kotlin.load.java.JvmAbi import org.jetbrains.kotlin.resolve.BindingContext import org.jetbrains.kotlin.resolve.jvm.jvmSignature.KotlinToJvmSignatureMapper public class KotlinToJvmSignatureMapperImpl : KotlinToJvmSignatureMapper { // We use empty BindingContext, because it is only used by JetTypeMapper for purposes irrelevant to the needs of this class - private val typeMapper: JetTypeMapper = JetTypeMapper( - BindingContext.EMPTY, ClassBuilderMode.LIGHT_CLASSES, NoResolveFileClassesProvider, null) + private val typeMapper: JetTypeMapper = JetTypeMapper(BindingContext.EMPTY, ClassBuilderMode.LIGHT_CLASSES, NoResolveFileClassesProvider, null, JvmAbi.DEFAULT_MODULE_NAME) override fun mapToJvmMethodSignature(function: FunctionDescriptor) = typeMapper.mapSignature(function) } diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/BuilderFactoryForDuplicateSignatureDiagnostics.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/BuilderFactoryForDuplicateSignatureDiagnostics.kt index fb9b9411895..1d8d3f2a9f7 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/BuilderFactoryForDuplicateSignatureDiagnostics.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/BuilderFactoryForDuplicateSignatureDiagnostics.kt @@ -44,11 +44,12 @@ class BuilderFactoryForDuplicateSignatureDiagnostics( bindingContext: BindingContext, private val diagnostics: DiagnosticSink, fileClassesProvider: JvmFileClassesProvider, - incrementalCache: IncrementalCache? + incrementalCache: IncrementalCache?, + moduleName: String ) : SignatureCollectingClassBuilderFactory(builderFactory) { // Avoid errors when some classes are not loaded for some reason - private val typeMapper = JetTypeMapper(bindingContext, ClassBuilderMode.LIGHT_CLASSES, fileClassesProvider, incrementalCache) + private val typeMapper = JetTypeMapper(bindingContext, ClassBuilderMode.LIGHT_CLASSES, fileClassesProvider, incrementalCache, moduleName) override fun handleClashingSignatures(data: ConflictingJvmDeclarationsData) { val noOwnImplementations = data.signatureOrigins.all { it.originKind in EXTERNAL_SOURCES_KINDS } 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 61ae02fc441..3c9d503f8cb 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/GenerationState.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/GenerationState.kt @@ -92,11 +92,11 @@ public class GenerationState @JvmOverloads constructor( incrementalCompilationComponents.getIncrementalCache(targetId) else null + public val moduleName: String = moduleName ?: JvmCodegenUtil.getModuleName(module) public val classBuilderMode: ClassBuilderMode = builderFactory.getClassBuilderMode() public val bindingTrace: BindingTrace = DelegatingBindingTrace(bindingContext, "trace in GenerationState") public val bindingContext: BindingContext = bindingTrace.getBindingContext() - public val typeMapper: JetTypeMapper = JetTypeMapper(this.bindingContext, classBuilderMode, fileClassesProvider, - getIncrementalCacheForThisTarget()) + public val typeMapper: JetTypeMapper = JetTypeMapper(this.bindingContext, classBuilderMode, fileClassesProvider, getIncrementalCacheForThisTarget(), this.moduleName) public val intrinsics: IntrinsicMethods = IntrinsicMethods() public val samWrapperClasses: SamWrapperClasses = SamWrapperClasses(this) public val inlineCycleReporter: InlineCycleReporter = InlineCycleReporter(diagnostics) @@ -117,7 +117,6 @@ public class GenerationState @JvmOverloads constructor( public val isInlineEnabled: Boolean = !disableInline @JvmName("isInlineEnabled") get - public val moduleName: String = moduleName ?: JvmCodegenUtil.getModuleName(module) public val rootContext: CodegenContext<*> = RootContext(this) @@ -125,7 +124,8 @@ public class GenerationState @JvmOverloads constructor( val optimizationClassBuilderFactory = OptimizationClassBuilderFactory(builderFactory, disableOptimization) var interceptedBuilderFactory: ClassBuilderFactory = BuilderFactoryForDuplicateSignatureDiagnostics( optimizationClassBuilderFactory, this.bindingContext, diagnostics, fileClassesProvider, - getIncrementalCacheForThisTarget()) + getIncrementalCacheForThisTarget(), + this.moduleName) interceptedBuilderFactory = BuilderFactoryForDuplicateClassNameDiagnostics(interceptedBuilderFactory, diagnostics); diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/JetTypeMapper.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/JetTypeMapper.java index 480806be126..b1f8a62c6e3 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/JetTypeMapper.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/JetTypeMapper.java @@ -87,17 +87,20 @@ public class JetTypeMapper { private final ClassBuilderMode classBuilderMode; private final JvmFileClassesProvider fileClassesProvider; private final IncrementalCache incrementalCache; + private final String moduleName; public JetTypeMapper( @NotNull BindingContext bindingContext, @NotNull ClassBuilderMode classBuilderMode, @NotNull JvmFileClassesProvider fileClassesProvider, - @Nullable IncrementalCache incrementalCache + @Nullable IncrementalCache incrementalCache, + @NotNull String moduleName ) { this.bindingContext = bindingContext; this.classBuilderMode = classBuilderMode; this.fileClassesProvider = fileClassesProvider; this.incrementalCache = incrementalCache; + this.moduleName = moduleName; } @NotNull @@ -828,7 +831,7 @@ public class JetTypeMapper { ? JvmAbi.getterName(propertyName) : JvmAbi.setterName(propertyName); - return isAccessor ? "access$" + accessorName : accessorName; + return updateMemberNameIfInternal(isAccessor ? "access$" + accessorName : accessorName, descriptor); } else if (isFunctionLiteral(descriptor)) { PsiElement element = DescriptorToSourceUtils.getSourceFromDescriptor(descriptor); @@ -848,10 +851,40 @@ public class JetTypeMapper { return OperatorConventions.INVOKE.asString(); } else { - return descriptor.getName().asString(); + return updateMemberNameIfInternal(descriptor.getName().asString(), descriptor); } } + @NotNull + public static String mapDefaultFieldName(@NotNull PropertyDescriptor propertyDescriptor, boolean isDelegated) { + String name; + if (propertyDescriptor instanceof AccessorForPropertyDescriptor) { + name = ((AccessorForPropertyDescriptor) propertyDescriptor).getCalleeDescriptor().getName().asString(); + } + else { + name = propertyDescriptor.getName().asString(); + } + return isDelegated ? name + JvmAbi.DELEGATED_PROPERTY_NAME_SUFFIX : name; + } + + @NotNull + private String updateMemberNameIfInternal(@NotNull String name, @NotNull CallableMemberDescriptor descriptor) { + if (descriptor.getContainingDeclaration() instanceof ScriptDescriptor) { + //script properties should be public + return name; + } + + if (DescriptorUtils.isTopLevelDeclaration(descriptor)) { + return name; + } + + if (!(descriptor instanceof ConstructorDescriptor) && descriptor.getVisibility() == Visibilities.INTERNAL) { + return name + "$" + JvmCodegenUtil.sanitizeAsJavaIdentifier(moduleName); + } + + return name; + } + @NotNull public JvmMethodSignature mapSignature(@NotNull FunctionDescriptor descriptor) { return mapSignature(descriptor, OwnerKind.IMPLEMENTATION); diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/PackagePartClassUtils.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/PackagePartClassUtils.kt index 9891b3f76b7..d1a4ed18251 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/PackagePartClassUtils.kt +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/PackagePartClassUtils.kt @@ -40,7 +40,7 @@ public object PackagePartClassUtils { else capitalizeAsJavaClassName(sanitizeAsJavaIdentifier(str)) + PART_CLASS_NAME_SUFFIX - private @JvmStatic fun sanitizeAsJavaIdentifier(str: String): String = + public @JvmStatic fun sanitizeAsJavaIdentifier(str: String): String = str.replace("[^\\p{L}\\p{Digit}]".toRegex(), "_") private @JvmStatic fun capitalizeAsJavaClassName(str: String): String = diff --git a/compiler/testData/codegen/box/mangling/internalOverride.kt b/compiler/testData/codegen/box/mangling/internalOverride.kt new file mode 100644 index 00000000000..b8ac1e207a1 --- /dev/null +++ b/compiler/testData/codegen/box/mangling/internalOverride.kt @@ -0,0 +1,29 @@ +open class A { + internal open val field = "AF" + + internal open fun test(): String = "AM" +} + +fun invokeOnA(a: A) = a.test() + a.field + +class Z : A() { + override val field: String = "ZF" + + override fun test(): String = "ZM" +} + +fun box() : String { + var invokeOnA = invokeOnA(A()) + if (invokeOnA != "AMAF") return "fail 1: $invokeOnA" + + invokeOnA = invokeOnA(Z()) + if (invokeOnA != "ZMZF") return "fail 2: $invokeOnA" + + val z = Z().test() + if (z != "ZM") return "fail 3: $z" + + val f = Z().field + if (f != "ZF") return "fail 4: $f" + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/mangling/internalOverrideSuperCall.kt b/compiler/testData/codegen/box/mangling/internalOverrideSuperCall.kt new file mode 100644 index 00000000000..64424c1dd80 --- /dev/null +++ b/compiler/testData/codegen/box/mangling/internalOverrideSuperCall.kt @@ -0,0 +1,21 @@ +open class A { + internal open val field = "F" + + internal open fun test(): String = "A" +} + +class Z : A() { + override fun test(): String = super.test() + + override val field = super.field +} + +fun box() : String { + val z = Z().test() + if (z != "A") return "fail 1: $z" + + val f = Z().field + if (f != "F") return "fail 2: $f" + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/mangling/publicOverride.kt b/compiler/testData/codegen/box/mangling/publicOverride.kt new file mode 100644 index 00000000000..0087a1fbc66 --- /dev/null +++ b/compiler/testData/codegen/box/mangling/publicOverride.kt @@ -0,0 +1,29 @@ +open class A { + internal open val field = "AF" + + internal open fun test(): String = "AM" +} + +fun invokeOnA(a: A) = a.test() + a.field + +class Z : A() { + public override val field: String = "ZF" + + public override fun test(): String = "ZM" +} + +fun box() : String { + var invokeOnA = invokeOnA(A()) + if (invokeOnA != "AMAF") return "fail 1: $invokeOnA" + + invokeOnA = invokeOnA(Z()) + if (invokeOnA != "ZMZF") return "fail 2: $invokeOnA" + + val z = Z().test() + if (z != "ZM") return "fail 3: $z" + + val f = Z().field + if (f != "ZF") return "fail 4: $f" + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/mangling/publicOverrideSuperCall.kt b/compiler/testData/codegen/box/mangling/publicOverrideSuperCall.kt new file mode 100644 index 00000000000..422f510101e --- /dev/null +++ b/compiler/testData/codegen/box/mangling/publicOverrideSuperCall.kt @@ -0,0 +1,21 @@ +open class A { + internal open val field = "F" + + internal open fun test(): String = "A" +} + +class Z : A() { + public override fun test(): String = super.test() + + public override val field = super.field +} + +fun box() : String { + val z = Z().test() + if (z != "A") return "fail 1: $z" + + val f = Z().field + if (f != "F") return "fail 2: $f" + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/boxInline/anonymousObject/capturedLambdaInInlineObject.1.kt b/compiler/testData/codegen/boxInline/anonymousObject/capturedLambdaInInlineObject.1.kt index 6e404cbbe90..a5b838f9e35 100644 --- a/compiler/testData/codegen/boxInline/anonymousObject/capturedLambdaInInlineObject.1.kt +++ b/compiler/testData/codegen/boxInline/anonymousObject/capturedLambdaInInlineObject.1.kt @@ -1,6 +1,6 @@ //NO_CHECK_LAMBDA_INLINING import test.* -internal fun box(): String { +fun box(): String { return bar { "OK" }.run() } \ No newline at end of file diff --git a/compiler/testData/codegen/boxWithJava/mangling/JavaClass.java b/compiler/testData/codegen/boxWithJava/mangling/JavaClass.java new file mode 100644 index 00000000000..24276d92581 --- /dev/null +++ b/compiler/testData/codegen/boxWithJava/mangling/JavaClass.java @@ -0,0 +1,5 @@ +public class JavaClass extends A { + public String test() { + return "Java"; + } +} \ No newline at end of file diff --git a/compiler/testData/codegen/boxWithJava/mangling/internalOverride.kt b/compiler/testData/codegen/boxWithJava/mangling/internalOverride.kt new file mode 100644 index 00000000000..62d0799db85 --- /dev/null +++ b/compiler/testData/codegen/boxWithJava/mangling/internalOverride.kt @@ -0,0 +1,11 @@ +open class A { + internal open fun test(): String = "Kotlin" +} + +fun box(): String { + if (A().test() != "Kotlin") return "fail 1: ${A().test()}" + + if (JavaClass().test() != "Java") return "fail 2: ${JavaClass().test()}" + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/boxWithStdlib/mangling/field.kt b/compiler/testData/codegen/boxWithStdlib/mangling/field.kt new file mode 100644 index 00000000000..1631cda984f --- /dev/null +++ b/compiler/testData/codegen/boxWithStdlib/mangling/field.kt @@ -0,0 +1,20 @@ +package test + +internal val noMangling = 1; + +class Z { + internal var noMangling = 1; +} + +fun box(): String { + val clazz = Z::class.java + val classField = clazz.getDeclaredField("noMangling") + if (classField == null) return "Class internal backing field should exist" + if (!classField.isSynthetic) return "Class internal backing field should be synthetic" + + val topLevel = Class.forName("test.FieldKt").getDeclaredField("noMangling") + if (topLevel == null) return "Top level internal backing field should exist" + if (!topLevel.isSynthetic) return "Top level internal backing field should be synthetic" + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/boxWithStdlib/mangling/fun.kt b/compiler/testData/codegen/boxWithStdlib/mangling/fun.kt new file mode 100644 index 00000000000..a1ed4d89455 --- /dev/null +++ b/compiler/testData/codegen/boxWithStdlib/mangling/fun.kt @@ -0,0 +1,24 @@ +package test + +internal fun noMangling() = 1; + +class Z { + internal fun mangled() = 1; +} + +fun box(): String { + val clazz = Z::class.java + val declaredMethods = clazz.declaredMethods + + val mangled = declaredMethods.firstOrNull { + it.name.startsWith("mangled$") + } + if (mangled == null) return "Class internal function should exist" + if (!mangled.isSynthetic) return "Class internal function should be synthetic" + + val topLevel = Class.forName("test.FunKt").getMethod("noMangling") + if (topLevel == null) return "Top level internal function should exist" + if (!topLevel.isSynthetic) return "Top level internal function should be synthetic" + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/integration/ant/jvm/internalMembers/build.log.expected b/compiler/testData/integration/ant/jvm/internalMembers/build.log.expected new file mode 100644 index 00000000000..08608028f21 --- /dev/null +++ b/compiler/testData/integration/ant/jvm/internalMembers/build.log.expected @@ -0,0 +1,14 @@ +OUT: +Buildfile: [TestData]/build.xml + +build: + [kotlinc] Compiling [[TestData]/module1.kt] => [[Temp]/module1.jar] + [kotlinc] Compiling [[TestData]/module2.kt] => [[Temp]/module2.jar] + [java] A_OA_K + [java] B_OB_K + [java] C_OC_K + +BUILD SUCCESSFUL +Total time: [time] + +Return code: 0 diff --git a/compiler/testData/integration/ant/jvm/internalMembers/build.xml b/compiler/testData/integration/ant/jvm/internalMembers/build.xml new file mode 100644 index 00000000000..72c06c42926 --- /dev/null +++ b/compiler/testData/integration/ant/jvm/internalMembers/build.xml @@ -0,0 +1,21 @@ + + + + + + + + + + + + + + + + + + + + + diff --git a/compiler/testData/integration/ant/jvm/internalMembers/module1.kt b/compiler/testData/integration/ant/jvm/internalMembers/module1.kt new file mode 100644 index 00000000000..9e67cb4f6e1 --- /dev/null +++ b/compiler/testData/integration/ant/jvm/internalMembers/module1.kt @@ -0,0 +1,11 @@ +package hello + +open class A { + + internal val z: String = "A_O" + + internal fun test() = "A_K" + +} + +public fun invokeOnA(a: A) = a.z + a.test() \ No newline at end of file diff --git a/compiler/testData/integration/ant/jvm/internalMembers/module2.kt b/compiler/testData/integration/ant/jvm/internalMembers/module2.kt new file mode 100644 index 00000000000..0692e9f68bc --- /dev/null +++ b/compiler/testData/integration/ant/jvm/internalMembers/module2.kt @@ -0,0 +1,29 @@ +package hello + +open class B : A() { + + internal val z: String = "B_O" + + internal fun test() = "B_K" + +} + +class C : A() { + + public val z: String = "C_O" + + public fun test() = "C_K" + +} + + +public fun invokeOnB(b: B) = b.z + b.test() + +public fun invokeOnC(c: C) = c.z + c.test() + +fun main(args: Array) { + val b = B() + println(invokeOnA(b)) + println(invokeOnB(b)) + println(invokeOnC(C())) +} \ No newline at end of file diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/generated/BlackBoxCodegenTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/codegen/generated/BlackBoxCodegenTestGenerated.java index 44b9d616cb2..720e134cac1 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/generated/BlackBoxCodegenTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/generated/BlackBoxCodegenTestGenerated.java @@ -5018,6 +5018,39 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } } + @TestMetadata("compiler/testData/codegen/box/mangling") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Mangling extends AbstractBlackBoxCodegenTest { + public void testAllFilesPresentInMangling() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/box/mangling"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("internalOverride.kt") + public void testInternalOverride() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/box/mangling/internalOverride.kt"); + doTest(fileName); + } + + @TestMetadata("internalOverrideSuperCall.kt") + public void testInternalOverrideSuperCall() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/box/mangling/internalOverrideSuperCall.kt"); + doTest(fileName); + } + + @TestMetadata("publicOverride.kt") + public void testPublicOverride() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/box/mangling/publicOverride.kt"); + doTest(fileName); + } + + @TestMetadata("publicOverrideSuperCall.kt") + public void testPublicOverrideSuperCall() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/box/mangling/publicOverrideSuperCall.kt"); + doTest(fileName); + } + } + @TestMetadata("compiler/testData/codegen/box/multiDecl") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/generated/BlackBoxWithJavaCodegenTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/codegen/generated/BlackBoxWithJavaCodegenTestGenerated.java index b6e801c42cb..b3a1b8b6e9a 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/generated/BlackBoxWithJavaCodegenTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/generated/BlackBoxWithJavaCodegenTestGenerated.java @@ -65,6 +65,12 @@ public class BlackBoxWithJavaCodegenTestGenerated extends AbstractBlackBoxCodege doTestWithJava(fileName); } + @TestMetadata("mangling") + public void testMangling() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/boxWithJava/mangling/"); + doTestWithJava(fileName); + } + @TestMetadata("platformName") public void testPlatformName() throws Exception { String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/boxWithJava/platformName/"); diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/generated/BlackBoxWithStdlibCodegenTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/codegen/generated/BlackBoxWithStdlibCodegenTestGenerated.java index 756d0eb6c4e..66cb6551baf 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/generated/BlackBoxWithStdlibCodegenTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/generated/BlackBoxWithStdlibCodegenTestGenerated.java @@ -2228,6 +2228,27 @@ public class BlackBoxWithStdlibCodegenTestGenerated extends AbstractBlackBoxCode } } + @TestMetadata("compiler/testData/codegen/boxWithStdlib/mangling") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Mangling extends AbstractBlackBoxCodegenTest { + public void testAllFilesPresentInMangling() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/boxWithStdlib/mangling"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("field.kt") + public void testField() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/boxWithStdlib/mangling/field.kt"); + doTestWithStdlib(fileName); + } + + @TestMetadata("fun.kt") + public void testFun() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/boxWithStdlib/mangling/fun.kt"); + doTestWithStdlib(fileName); + } + } + @TestMetadata("compiler/testData/codegen/boxWithStdlib/multiDeclForArray") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) diff --git a/compiler/tests/org/jetbrains/kotlin/integration/AntTaskTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/integration/AntTaskTestGenerated.java index df3935fb3f9..46d019aad90 100644 --- a/compiler/tests/org/jetbrains/kotlin/integration/AntTaskTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/integration/AntTaskTestGenerated.java @@ -59,6 +59,12 @@ public class AntTaskTestGenerated extends AbstractAntTaskTest { doTest(fileName); } + @TestMetadata("internalMembers") + public void testInternalMembers() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/integration/ant/jvm/internalMembers/"); + doTest(fileName); + } + @TestMetadata("jvmClasspath") public void testJvmClasspath() throws Exception { String fileName = JetTestUtils.navigationMetadata("compiler/testData/integration/ant/jvm/jvmClasspath/"); diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/JvmAbi.java b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/JvmAbi.java index 411080f1f81..690963dff1d 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/JvmAbi.java +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/JvmAbi.java @@ -62,11 +62,6 @@ public final class JvmAbi { return propertyName.asString() + ANNOTATED_PROPERTY_METHOD_NAME_SUFFIX; } - @NotNull - public static String getDefaultFieldNameForProperty(@NotNull Name propertyName, boolean isDelegated) { - return isDelegated ? propertyName.asString() + DELEGATED_PROPERTY_NAME_SUFFIX : propertyName.asString(); - } - public static boolean isGetterName(@NotNull String name) { return name.startsWith(GET_PREFIX) || name.startsWith(IS_PREFIX); }