From 08e7a9d826616dd4647f585c7e2716b8f6c13163 Mon Sep 17 00:00:00 2001 From: Valentin Kipyatkov Date: Mon, 7 Sep 2015 20:21:20 +0300 Subject: [PATCH] Made methods generated from declarations marked with @HiddenDeclaration synthetic in JVM --- .../org/jetbrains/kotlin/codegen/AsmUtil.java | 6 +++++ .../testData/writeFlags/hidden/function.kt | 7 +++++ .../writeFlags/hidden/propertyGetter.kt | 9 +++++++ .../writeFlags/hidden/propertySetter.kt | 9 +++++++ .../codegen/flags/AbstractWriteFlagsTest.java | 18 +++++++++---- .../flags/WriteFlagsTestGenerated.java | 27 +++++++++++++++++++ 6 files changed, 71 insertions(+), 5 deletions(-) create mode 100644 compiler/testData/writeFlags/hidden/function.kt create mode 100644 compiler/testData/writeFlags/hidden/propertyGetter.kt create mode 100644 compiler/testData/writeFlags/hidden/propertySetter.kt diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/AsmUtil.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/AsmUtil.java index 2e06e9390a0..d5f62a13efa 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/AsmUtil.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/AsmUtil.java @@ -40,6 +40,7 @@ import org.jetbrains.kotlin.load.java.descriptors.JavaCallableMemberDescriptor; import org.jetbrains.kotlin.name.FqName; import org.jetbrains.kotlin.resolve.DescriptorUtils; import org.jetbrains.kotlin.resolve.annotations.AnnotationsPackage; +import org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilPackage; import org.jetbrains.kotlin.resolve.inline.InlineUtil; import org.jetbrains.kotlin.resolve.jvm.JvmClassName; import org.jetbrains.kotlin.resolve.jvm.JvmPackage; @@ -218,6 +219,11 @@ public class AsmUtil { int flags = getVisibilityAccessFlag(functionDescriptor); flags |= getVarargsFlag(functionDescriptor); flags |= getDeprecatedAccessFlag(functionDescriptor); + if (DescriptorUtilPackage.isAnnotatedAsHidden(functionDescriptor) + || functionDescriptor instanceof PropertyAccessorDescriptor + && DescriptorUtilPackage.isAnnotatedAsHidden(((PropertyAccessorDescriptor) functionDescriptor).getCorrespondingProperty())) { + flags |= ACC_SYNTHETIC; + } return flags; } diff --git a/compiler/testData/writeFlags/hidden/function.kt b/compiler/testData/writeFlags/hidden/function.kt new file mode 100644 index 00000000000..a38f7cd1dc6 --- /dev/null +++ b/compiler/testData/writeFlags/hidden/function.kt @@ -0,0 +1,7 @@ +class MyClass() { + @HiddenDeclaration fun test() {} +} + +// TESTED_OBJECT_KIND: function +// TESTED_OBJECTS: MyClass, test +// FLAGS: ACC_SYNTHETIC, ACC_PUBLIC, ACC_FINAL diff --git a/compiler/testData/writeFlags/hidden/propertyGetter.kt b/compiler/testData/writeFlags/hidden/propertyGetter.kt new file mode 100644 index 00000000000..5520fd0c600 --- /dev/null +++ b/compiler/testData/writeFlags/hidden/propertyGetter.kt @@ -0,0 +1,9 @@ +class MyClass() { + @HiddenDeclaration var test: Int + get() = 0 + set(value) {} +} + +// TESTED_OBJECT_KIND: function +// TESTED_OBJECTS: MyClass, getTest +// FLAGS: ACC_SYNTHETIC, ACC_PUBLIC, ACC_FINAL diff --git a/compiler/testData/writeFlags/hidden/propertySetter.kt b/compiler/testData/writeFlags/hidden/propertySetter.kt new file mode 100644 index 00000000000..467568cdab9 --- /dev/null +++ b/compiler/testData/writeFlags/hidden/propertySetter.kt @@ -0,0 +1,9 @@ +class MyClass() { + @HiddenDeclaration var test: Int + get() = 0 + set(value) {} +} + +// TESTED_OBJECT_KIND: function +// TESTED_OBJECTS: MyClass, setTest +// FLAGS: ACC_SYNTHETIC, ACC_PUBLIC, ACC_FINAL diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/flags/AbstractWriteFlagsTest.java b/compiler/tests/org/jetbrains/kotlin/codegen/flags/AbstractWriteFlagsTest.java index 3b56e8d2178..7843ccd0894 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/flags/AbstractWriteFlagsTest.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/flags/AbstractWriteFlagsTest.java @@ -98,9 +98,14 @@ public abstract class AbstractWriteFlagsTest extends UsefulTestCase { assertNotNull(outputFile); ClassReader cr = new ClassReader(outputFile.asByteArray()); - TestClassVisitor classVisitor = getClassVisitor(testedObject.kind, testedObject.name); + TestClassVisitor classVisitor = getClassVisitor(testedObject.kind, testedObject.name, false); cr.accept(classVisitor, ClassReader.SKIP_CODE); + if (!classVisitor.isExists()) { + classVisitor = getClassVisitor(testedObject.kind, testedObject.name, true); + cr.accept(classVisitor, ClassReader.SKIP_CODE); + } + boolean isObjectExists = !Boolean.valueOf(findStringWithPrefixes(testedObject.textData, "// ABSENT: ")); assertEquals("Wrong object existence state: " + testedObject, isObjectExists, classVisitor.isExists()); @@ -158,12 +163,12 @@ public abstract class AbstractWriteFlagsTest extends UsefulTestCase { } } - private static TestClassVisitor getClassVisitor(String visitorKind, String testedObjectName) { + private static TestClassVisitor getClassVisitor(String visitorKind, String testedObjectName, boolean allowSynthetic) { if (visitorKind.equals("class")) { return new ClassFlagsVisitor(); } else if (visitorKind.equals("function")) { - return new FunctionFlagsVisitor(testedObjectName); + return new FunctionFlagsVisitor(testedObjectName, allowSynthetic); } else if (visitorKind.equals("property")) { return new PropertyFlagsVisitor(testedObjectName); @@ -227,14 +232,17 @@ public abstract class AbstractWriteFlagsTest extends UsefulTestCase { private static class FunctionFlagsVisitor extends TestClassVisitor { private int access = 0; private final String funName; + private final boolean allowSynthetic; - public FunctionFlagsVisitor(String name) { + public FunctionFlagsVisitor(String name, boolean allowSynthetic) { funName = name; + this.allowSynthetic = allowSynthetic; } @Override public MethodVisitor visitMethod(int access, @NotNull String name, @NotNull String desc, String signature, String[] exceptions) { - if (name.equals(funName) && (access & Opcodes.ACC_SYNTHETIC) == 0) { + if (name.equals(funName)) { + if (!allowSynthetic && (access & Opcodes.ACC_SYNTHETIC) != 0) return null; this.access = access; isExists = true; } diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/flags/WriteFlagsTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/codegen/flags/WriteFlagsTestGenerated.java index 41638666d1d..328743b172e 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/flags/WriteFlagsTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/flags/WriteFlagsTestGenerated.java @@ -518,6 +518,33 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest { } } + @TestMetadata("compiler/testData/writeFlags/hidden") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Hidden extends AbstractWriteFlagsTest { + public void testAllFilesPresentInHidden() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/hidden"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("function.kt") + public void testFunction() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/writeFlags/hidden/function.kt"); + doTest(fileName); + } + + @TestMetadata("propertyGetter.kt") + public void testPropertyGetter() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/writeFlags/hidden/propertyGetter.kt"); + doTest(fileName); + } + + @TestMetadata("propertySetter.kt") + public void testPropertySetter() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/writeFlags/hidden/propertySetter.kt"); + doTest(fileName); + } + } + @TestMetadata("compiler/testData/writeFlags/innerClass") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class)