diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/AsmUtil.java b/compiler/backend/src/org/jetbrains/jet/codegen/AsmUtil.java index 775086de62a..3caba7cb16c 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/AsmUtil.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/AsmUtil.java @@ -143,6 +143,20 @@ public class AsmUtil { return defaultMapping; } + /* + Use this method to get visibility flag for class to define it in byte code (v.defineClass method). + For other cases use getVisibilityAccessFlag(MemberDescriptor descriptor) + Classes in byte code should be public or package private + */ + public static int getVisibilityAccessFlagForClass(ClassDescriptor descriptor) { + if (descriptor.getContainingDeclaration() instanceof NamespaceDescriptor || + descriptor.getVisibility() == Visibilities.PUBLIC || + descriptor.getVisibility() == Visibilities.INTERNAL) { + return ACC_PUBLIC; + } + return NO_FLAG_PACKAGE_PRIVATE; + } + public static int getModalityAccessFlag(@NotNull MemberDescriptor descriptor) { switch (descriptor.getModality()) { case ABSTRACT: return ACC_ABSTRACT; @@ -224,7 +238,7 @@ public class AsmUtil { public static void genClosureFields(CalculatedClosure closure, ClassBuilder v, JetTypeMapper typeMapper) { final ClassifierDescriptor captureThis = closure.getCaptureThis(); - final int access = ACC_PUBLIC | ACC_SYNTHETIC | ACC_FINAL; + final int access = NO_FLAG_PACKAGE_PRIVATE | ACC_SYNTHETIC | ACC_FINAL; if (captureThis != null) { v.newField(null, access, CAPTURED_THIS_FIELD, typeMapper.mapType(captureThis).getDescriptor(), null, null); diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java index 580a519a9cb..1f8e9f4cc70 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java @@ -131,7 +131,8 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { } int access = 0; - access |= ACC_PUBLIC; + + access |= getVisibilityAccessFlagForClass(descriptor); if (isAbstract) { access |= ACC_ABSTRACT; } @@ -210,7 +211,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { } } - int innerClassAccess = ACC_PUBLIC | ACC_FINAL | ACC_STATIC; + int innerClassAccess = getVisibilityAccessFlag(classObjectDescriptor) | ACC_FINAL | ACC_STATIC; v.visitInnerClass(classAsmType.getInternalName() + JvmAbi.CLASS_OBJECT_SUFFIX, classAsmType.getInternalName(), JvmAbi.CLASS_OBJECT_CLASS_NAME, innerClassAccess); @@ -219,7 +220,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { private void writeInnerClass(ClassDescriptor innerClass, boolean isStatic) { // TODO: proper access - int innerClassAccess = ACC_PUBLIC; + int innerClassAccess = getVisibilityAccessFlag(innerClass); if (innerClass.getModality() == Modality.FINAL) { innerClassAccess |= ACC_FINAL; } diff --git a/compiler/testData/writeFlags/class/visibility/internal/class.kt b/compiler/testData/writeFlags/class/visibility/internal/class.kt new file mode 100644 index 00000000000..c50551118f4 --- /dev/null +++ b/compiler/testData/writeFlags/class/visibility/internal/class.kt @@ -0,0 +1,6 @@ +class MyClass() { +} + +// TESTED_OBJECT_KIND: class +// TESTED_OBJECTS: MyClass +// FLAGS: ACC_FINAL, ACC_PUBLIC, ACC_SUPER diff --git a/compiler/testData/writeFlags/class/visibility/internal/enum.kt b/compiler/testData/writeFlags/class/visibility/internal/enum.kt new file mode 100644 index 00000000000..fe2786b49c7 --- /dev/null +++ b/compiler/testData/writeFlags/class/visibility/internal/enum.kt @@ -0,0 +1,6 @@ +enum class MyClass() { +} + +// TESTED_OBJECT_KIND: class +// TESTED_OBJECTS: MyClass +// FLAGS: ACC_FINAL, ACC_PUBLIC, ACC_SUPER, ACC_ENUM diff --git a/compiler/testData/writeFlags/class/visibility/internal/innerClass.kt b/compiler/testData/writeFlags/class/visibility/internal/innerClass.kt new file mode 100644 index 00000000000..275464be51f --- /dev/null +++ b/compiler/testData/writeFlags/class/visibility/internal/innerClass.kt @@ -0,0 +1,8 @@ +class Foo { + class MyClass() { + } +} + +// TESTED_OBJECT_KIND: class +// TESTED_OBJECTS: Foo$MyClass +// FLAGS: ACC_FINAL, ACC_PUBLIC, ACC_SUPER diff --git a/compiler/testData/writeFlags/class/visibility/internal/innerEnum.kt b/compiler/testData/writeFlags/class/visibility/internal/innerEnum.kt new file mode 100644 index 00000000000..a4286f152bf --- /dev/null +++ b/compiler/testData/writeFlags/class/visibility/internal/innerEnum.kt @@ -0,0 +1,8 @@ +class Foo { + enum class MyClass() { + } +} + +// TESTED_OBJECT_KIND: class +// TESTED_OBJECTS: Foo$MyClass +// FLAGS: ACC_FINAL, ACC_PUBLIC, ACC_SUPER, ACC_ENUM diff --git a/compiler/testData/writeFlags/class/visibility/internal/innerObject.kt b/compiler/testData/writeFlags/class/visibility/internal/innerObject.kt new file mode 100644 index 00000000000..fef340bdda9 --- /dev/null +++ b/compiler/testData/writeFlags/class/visibility/internal/innerObject.kt @@ -0,0 +1,8 @@ +class Foo { + object MyClass { + } +} + +// TESTED_OBJECT_KIND: class +// TESTED_OBJECTS: Foo$MyClass +// FLAGS: ACC_FINAL, ACC_PUBLIC, ACC_SUPER diff --git a/compiler/testData/writeFlags/class/visibility/internal/innerTrait.kt b/compiler/testData/writeFlags/class/visibility/internal/innerTrait.kt new file mode 100644 index 00000000000..2eb3546370c --- /dev/null +++ b/compiler/testData/writeFlags/class/visibility/internal/innerTrait.kt @@ -0,0 +1,8 @@ +class Foo { + trait MyClass { + } +} + +// TESTED_OBJECT_KIND: class +// TESTED_OBJECTS: Foo$MyClass +// FLAGS: ACC_ABSTRACT, ACC_INTERFACE, ACC_PUBLIC diff --git a/compiler/testData/writeFlags/class/visibility/internal/object.kt b/compiler/testData/writeFlags/class/visibility/internal/object.kt new file mode 100644 index 00000000000..8b52e81c2a3 --- /dev/null +++ b/compiler/testData/writeFlags/class/visibility/internal/object.kt @@ -0,0 +1,6 @@ +object MyClass { +} + +// TESTED_OBJECT_KIND: class +// TESTED_OBJECTS: MyClass +// FLAGS: ACC_FINAL, ACC_PUBLIC, ACC_SUPER diff --git a/compiler/testData/writeFlags/class/visibility/internal/trait.kt b/compiler/testData/writeFlags/class/visibility/internal/trait.kt new file mode 100644 index 00000000000..decaf46b670 --- /dev/null +++ b/compiler/testData/writeFlags/class/visibility/internal/trait.kt @@ -0,0 +1,6 @@ +trait MyClass { +} + +// TESTED_OBJECT_KIND: class +// TESTED_OBJECTS: MyClass +// FLAGS: ACC_ABSTRACT, ACC_INTERFACE, ACC_PUBLIC diff --git a/compiler/testData/writeFlags/class/visibility/private/class.kt b/compiler/testData/writeFlags/class/visibility/private/class.kt new file mode 100644 index 00000000000..4258c6c5ccb --- /dev/null +++ b/compiler/testData/writeFlags/class/visibility/private/class.kt @@ -0,0 +1,7 @@ +//ACC_PUBLIC because private in kotlin is package private in java + it should be visible in subpackages +private class MyClass() { +} + +// TESTED_OBJECT_KIND: class +// TESTED_OBJECTS: MyClass +// FLAGS: ACC_FINAL, ACC_PUBLIC, ACC_SUPER diff --git a/compiler/testData/writeFlags/class/visibility/private/enum.kt b/compiler/testData/writeFlags/class/visibility/private/enum.kt new file mode 100644 index 00000000000..37996ae9afe --- /dev/null +++ b/compiler/testData/writeFlags/class/visibility/private/enum.kt @@ -0,0 +1,6 @@ +private enum class MyClass() { +} + +// TESTED_OBJECT_KIND: class +// TESTED_OBJECTS: MyClass +// FLAGS: ACC_FINAL, ACC_PUBLIC, ACC_SUPER, ACC_ENUM diff --git a/compiler/testData/writeFlags/class/visibility/private/innerClass.kt b/compiler/testData/writeFlags/class/visibility/private/innerClass.kt new file mode 100644 index 00000000000..2c50fdc9f04 --- /dev/null +++ b/compiler/testData/writeFlags/class/visibility/private/innerClass.kt @@ -0,0 +1,8 @@ +class Foo { + private class MyClass() { + } +} + +// TESTED_OBJECT_KIND: class +// TESTED_OBJECTS: Foo$MyClass +// FLAGS: ACC_FINAL, ACC_SUPER diff --git a/compiler/testData/writeFlags/class/visibility/private/innerEnum.kt b/compiler/testData/writeFlags/class/visibility/private/innerEnum.kt new file mode 100644 index 00000000000..0b00fc78e3c --- /dev/null +++ b/compiler/testData/writeFlags/class/visibility/private/innerEnum.kt @@ -0,0 +1,10 @@ +// NO_FLAGS because we put enum in class object of foo. When it will be fixed - MyClass should have ACC_PRIVATE flag + +class Foo { + private enum class MyClass() { + } +} + +// TESTED_OBJECT_KIND: class +// TESTED_OBJECTS: Foo$MyClass +// FLAGS: ACC_FINAL, ACC_SUPER, ACC_ENUM diff --git a/compiler/testData/writeFlags/class/visibility/private/innerObject.kt b/compiler/testData/writeFlags/class/visibility/private/innerObject.kt new file mode 100644 index 00000000000..eada3ada326 --- /dev/null +++ b/compiler/testData/writeFlags/class/visibility/private/innerObject.kt @@ -0,0 +1,8 @@ +class Foo { + private object MyClass { + } +} + +// TESTED_OBJECT_KIND: class +// TESTED_OBJECTS: Foo$MyClass +// FLAGS: ACC_FINAL, ACC_SUPER diff --git a/compiler/testData/writeFlags/class/visibility/private/innerTrait.kt b/compiler/testData/writeFlags/class/visibility/private/innerTrait.kt new file mode 100644 index 00000000000..a98d1288027 --- /dev/null +++ b/compiler/testData/writeFlags/class/visibility/private/innerTrait.kt @@ -0,0 +1,8 @@ +class Foo { + private trait MyClass { + } +} + +// TESTED_OBJECT_KIND: class +// TESTED_OBJECTS: Foo$MyClass +// FLAGS: ACC_ABSTRACT, ACC_INTERFACE diff --git a/compiler/testData/writeFlags/class/visibility/private/object.kt b/compiler/testData/writeFlags/class/visibility/private/object.kt new file mode 100644 index 00000000000..05a134efb1e --- /dev/null +++ b/compiler/testData/writeFlags/class/visibility/private/object.kt @@ -0,0 +1,6 @@ +private object MyClass { +} + +// TESTED_OBJECT_KIND: class +// TESTED_OBJECTS: MyClass +// FLAGS: ACC_FINAL, ACC_PUBLIC, ACC_SUPER diff --git a/compiler/testData/writeFlags/class/visibility/private/trait.kt b/compiler/testData/writeFlags/class/visibility/private/trait.kt new file mode 100644 index 00000000000..73519fafceb --- /dev/null +++ b/compiler/testData/writeFlags/class/visibility/private/trait.kt @@ -0,0 +1,6 @@ +private trait MyClass { +} + +// TESTED_OBJECT_KIND: class +// TESTED_OBJECTS: MyClass +// FLAGS: ACC_ABSTRACT, ACC_INTERFACE, ACC_PUBLIC diff --git a/compiler/testData/writeFlags/class/visibility/public/class.kt b/compiler/testData/writeFlags/class/visibility/public/class.kt new file mode 100644 index 00000000000..7d571ffe024 --- /dev/null +++ b/compiler/testData/writeFlags/class/visibility/public/class.kt @@ -0,0 +1,6 @@ +public class MyClass() { +} + +// TESTED_OBJECT_KIND: class +// TESTED_OBJECTS: MyClass +// FLAGS: ACC_FINAL, ACC_PUBLIC, ACC_SUPER diff --git a/compiler/testData/writeFlags/class/visibility/public/enum.kt b/compiler/testData/writeFlags/class/visibility/public/enum.kt new file mode 100644 index 00000000000..5bcda7fb324 --- /dev/null +++ b/compiler/testData/writeFlags/class/visibility/public/enum.kt @@ -0,0 +1,6 @@ +public enum class MyClass() { +} + +// TESTED_OBJECT_KIND: class +// TESTED_OBJECTS: MyClass +// FLAGS: ACC_FINAL, ACC_PUBLIC, ACC_SUPER, ACC_ENUM diff --git a/compiler/testData/writeFlags/class/visibility/public/innerClass.kt b/compiler/testData/writeFlags/class/visibility/public/innerClass.kt new file mode 100644 index 00000000000..3fb9eb85a2c --- /dev/null +++ b/compiler/testData/writeFlags/class/visibility/public/innerClass.kt @@ -0,0 +1,8 @@ +class Foo { + public class MyClass() { + } +} + +// TESTED_OBJECT_KIND: class +// TESTED_OBJECTS: Foo$MyClass +// FLAGS: ACC_FINAL, ACC_PUBLIC, ACC_SUPER diff --git a/compiler/testData/writeFlags/class/visibility/public/innerEnum.kt b/compiler/testData/writeFlags/class/visibility/public/innerEnum.kt new file mode 100644 index 00000000000..cee3b737e99 --- /dev/null +++ b/compiler/testData/writeFlags/class/visibility/public/innerEnum.kt @@ -0,0 +1,8 @@ +class Foo { + public enum class MyClass() { + } +} + +// TESTED_OBJECT_KIND: class +// TESTED_OBJECTS: Foo$MyClass +// FLAGS: ACC_FINAL, ACC_PUBLIC, ACC_SUPER, ACC_ENUM diff --git a/compiler/testData/writeFlags/class/visibility/public/innerObject.kt b/compiler/testData/writeFlags/class/visibility/public/innerObject.kt new file mode 100644 index 00000000000..aa77149c1f4 --- /dev/null +++ b/compiler/testData/writeFlags/class/visibility/public/innerObject.kt @@ -0,0 +1,8 @@ +class Foo { + public object MyClass { + } +} + +// TESTED_OBJECT_KIND: class +// TESTED_OBJECTS: Foo$MyClass +// FLAGS: ACC_FINAL, ACC_PUBLIC, ACC_SUPER diff --git a/compiler/testData/writeFlags/class/visibility/public/innerTrait.kt b/compiler/testData/writeFlags/class/visibility/public/innerTrait.kt new file mode 100644 index 00000000000..14230c2ad16 --- /dev/null +++ b/compiler/testData/writeFlags/class/visibility/public/innerTrait.kt @@ -0,0 +1,8 @@ +class Foo { + public trait MyClass { + } +} + +// TESTED_OBJECT_KIND: class +// TESTED_OBJECTS: Foo$MyClass +// FLAGS: ACC_ABSTRACT, ACC_INTERFACE, ACC_PUBLIC diff --git a/compiler/testData/writeFlags/class/visibility/public/object.kt b/compiler/testData/writeFlags/class/visibility/public/object.kt new file mode 100644 index 00000000000..9011ed737da --- /dev/null +++ b/compiler/testData/writeFlags/class/visibility/public/object.kt @@ -0,0 +1,6 @@ +public object MyClass { +} + +// TESTED_OBJECT_KIND: class +// TESTED_OBJECTS: MyClass +// FLAGS: ACC_FINAL, ACC_PUBLIC, ACC_SUPER diff --git a/compiler/testData/writeFlags/class/visibility/public/trait.kt b/compiler/testData/writeFlags/class/visibility/public/trait.kt new file mode 100644 index 00000000000..6474e8547ff --- /dev/null +++ b/compiler/testData/writeFlags/class/visibility/public/trait.kt @@ -0,0 +1,6 @@ +public trait MyClass { +} + +// TESTED_OBJECT_KIND: class +// TESTED_OBJECTS: MyClass +// FLAGS: ACC_ABSTRACT, ACC_INTERFACE, ACC_PUBLIC diff --git a/compiler/testData/writeFlags/innerClass/visibility/internal.kt b/compiler/testData/writeFlags/innerClass/visibility/internal.kt new file mode 100644 index 00000000000..e5e7e408df6 --- /dev/null +++ b/compiler/testData/writeFlags/innerClass/visibility/internal.kt @@ -0,0 +1,8 @@ +class Foo { + class MyClass() { + } +} + +// TESTED_OBJECT_KIND: innerClass +// TESTED_OBJECTS: Foo, MyClass +// FLAGS: ACC_FINAL, ACC_PUBLIC diff --git a/compiler/testData/writeFlags/innerClass/visibility/internalClassObject.kt b/compiler/testData/writeFlags/innerClass/visibility/internalClassObject.kt new file mode 100644 index 00000000000..1107c97514b --- /dev/null +++ b/compiler/testData/writeFlags/innerClass/visibility/internalClassObject.kt @@ -0,0 +1,8 @@ +class Foo { + class object { + } +} + +// TESTED_OBJECT_KIND: innerClass +// TESTED_OBJECTS: Foo, object +// FLAGS: ACC_FINAL, ACC_PUBLIC, ACC_STATIC diff --git a/compiler/testData/writeFlags/innerClass/visibility/private.kt b/compiler/testData/writeFlags/innerClass/visibility/private.kt new file mode 100644 index 00000000000..3d691f34c2c --- /dev/null +++ b/compiler/testData/writeFlags/innerClass/visibility/private.kt @@ -0,0 +1,8 @@ +class Foo { + private class MyClass() { + } +} + +// TESTED_OBJECT_KIND: innerClass +// TESTED_OBJECTS: Foo, MyClass +// FLAGS: ACC_FINAL, ACC_PRIVATE diff --git a/compiler/testData/writeFlags/innerClass/visibility/privateClassObject.kt b/compiler/testData/writeFlags/innerClass/visibility/privateClassObject.kt new file mode 100644 index 00000000000..e664fa49864 --- /dev/null +++ b/compiler/testData/writeFlags/innerClass/visibility/privateClassObject.kt @@ -0,0 +1,8 @@ +class Foo { + private class object { + } +} + +// TESTED_OBJECT_KIND: innerClass +// TESTED_OBJECTS: Foo, object +// FLAGS: ACC_FINAL, ACC_PRIVATE, ACC_STATIC diff --git a/compiler/testData/writeFlags/innerClass/visibility/public.kt b/compiler/testData/writeFlags/innerClass/visibility/public.kt new file mode 100644 index 00000000000..bd65e7413a8 --- /dev/null +++ b/compiler/testData/writeFlags/innerClass/visibility/public.kt @@ -0,0 +1,8 @@ +class Foo { + public class MyClass() { + } +} + +// TESTED_OBJECT_KIND: innerClass +// TESTED_OBJECTS: Foo, MyClass +// FLAGS: ACC_FINAL, ACC_PUBLIC diff --git a/compiler/testData/writeFlags/innerClass/visibility/publicClassObject.kt b/compiler/testData/writeFlags/innerClass/visibility/publicClassObject.kt new file mode 100644 index 00000000000..21f248c377b --- /dev/null +++ b/compiler/testData/writeFlags/innerClass/visibility/publicClassObject.kt @@ -0,0 +1,8 @@ +class Foo { + public class object { + } +} + +// TESTED_OBJECT_KIND: innerClass +// TESTED_OBJECTS: Foo, object +// FLAGS: ACC_FINAL, ACC_PUBLIC, ACC_STATIC diff --git a/compiler/testData/writeFlags/property/visibility/internal.kt b/compiler/testData/writeFlags/property/visibility/internal.kt new file mode 100644 index 00000000000..cd5cb865054 --- /dev/null +++ b/compiler/testData/writeFlags/property/visibility/internal.kt @@ -0,0 +1,8 @@ +class Foo { + class MyClass() { + } +} + +// TESTED_OBJECT_KIND: property +// TESTED_OBJECTS: Foo$MyClass, this$0 +// FLAGS: ACC_FINAL, ACC_SYNTHETIC diff --git a/compiler/testData/writeFlags/property/visibility/private.kt b/compiler/testData/writeFlags/property/visibility/private.kt new file mode 100644 index 00000000000..cd2b7140606 --- /dev/null +++ b/compiler/testData/writeFlags/property/visibility/private.kt @@ -0,0 +1,8 @@ +class Foo { + private class MyClass() { + } +} + +// TESTED_OBJECT_KIND: property +// TESTED_OBJECTS: Foo$MyClass, this$0 +// FLAGS: ACC_FINAL, ACC_SYNTHETIC diff --git a/compiler/testData/writeFlags/property/visibility/public.kt b/compiler/testData/writeFlags/property/visibility/public.kt new file mode 100644 index 00000000000..a3b8e1b914f --- /dev/null +++ b/compiler/testData/writeFlags/property/visibility/public.kt @@ -0,0 +1,8 @@ +class Foo { + public class MyClass() { + } +} + +// TESTED_OBJECT_KIND: property +// TESTED_OBJECTS: Foo$MyClass, this$0 +// FLAGS: ACC_FINAL, ACC_SYNTHETIC diff --git a/compiler/tests/org/jetbrains/jet/codegen/FunctionGenTest.java b/compiler/tests/org/jetbrains/jet/codegen/FunctionGenTest.java index 3fc36bc3f3b..3fb48a12544 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/FunctionGenTest.java +++ b/compiler/tests/org/jetbrains/jet/codegen/FunctionGenTest.java @@ -96,7 +96,7 @@ public class FunctionGenTest extends CodegenTestCase { final Method f = foo.getMethod("f"); final Object closure = f.invoke(obj); final Class aClass = closure.getClass(); - final Field[] fields = aClass.getFields(); + final Field[] fields = aClass.getDeclaredFields(); assertEquals(1, fields.length); assertEquals("$s", fields[0].getName()); } diff --git a/compiler/tests/org/jetbrains/jet/codegen/flags/AbstractWriteFlagsTest.java b/compiler/tests/org/jetbrains/jet/codegen/flags/AbstractWriteFlagsTest.java index b0d14e75d28..a74f81288fc 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/flags/AbstractWriteFlagsTest.java +++ b/compiler/tests/org/jetbrains/jet/codegen/flags/AbstractWriteFlagsTest.java @@ -78,7 +78,7 @@ public abstract class AbstractWriteFlagsTest extends UsefulTestCase { classVisitor = getClassVisitor(testedObject.kind, testedObject.name); cr.accept(classVisitor, ClassReader.SKIP_CODE); int expectedAccess = getExpectedFlags(fileText); - assertEquals("Wrong access flag", expectedAccess, classVisitor.getAccess()); + assertEquals("Wrong access flag \n" + factory.asText(filename), expectedAccess, classVisitor.getAccess()); } } @@ -126,6 +126,9 @@ public abstract class AbstractWriteFlagsTest extends UsefulTestCase { else if (visitorKind.equals("property")) { return new PropertyFlagsVisitor(testedObjectName); } + else if (visitorKind.equals("innerClass")) { + return new InnerClassFlagsVisitor(testedObjectName); + } throw new IllegalArgumentException("Value of TESTED_OBJECT_KIND is incorrect: " + visitorKind); } @@ -213,4 +216,25 @@ public abstract class AbstractWriteFlagsTest extends UsefulTestCase { return access; } } + + private static class InnerClassFlagsVisitor extends TestClassVisitor { + private int access = 0; + private final String innerClassName; + + public InnerClassFlagsVisitor(String name) { + innerClassName = name; + } + + @Override + public void visitInnerClass(String innerClassInternalName, String outerClassInternalName, String name, int access) { + if (name.equals(innerClassName)) { + this.access = access; + } + } + + @Override + public int getAccess() { + return access; + } + } } diff --git a/compiler/tests/org/jetbrains/jet/codegen/flags/WriteFlagsTestGenerated.java b/compiler/tests/org/jetbrains/jet/codegen/flags/WriteFlagsTestGenerated.java index f6119aaf3c5..f2c0f7a8ed3 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/flags/WriteFlagsTestGenerated.java +++ b/compiler/tests/org/jetbrains/jet/codegen/flags/WriteFlagsTestGenerated.java @@ -28,14 +28,14 @@ import org.jetbrains.jet.codegen.flags.AbstractWriteFlagsTest; /** This class is generated by {@link org.jetbrains.jet.generators.tests.GenerateTests}. DO NOT MODIFY MANUALLY */ @TestMetadata("compiler/testData/writeFlags") -@InnerTestClasses({WriteFlagsTestGenerated.Class.class, WriteFlagsTestGenerated.Function.class, WriteFlagsTestGenerated.Property.class}) +@InnerTestClasses({WriteFlagsTestGenerated.Class.class, WriteFlagsTestGenerated.Function.class, WriteFlagsTestGenerated.InnerClass.class, WriteFlagsTestGenerated.Property.class}) public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest { public void testAllFilesPresentInWriteFlags() throws Exception { JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("compiler/testData/writeFlags"), "kt", true); } @TestMetadata("compiler/testData/writeFlags/class") - @InnerTestClasses({Class.AccessFlags.class, Class.DeprecatedFlag.class}) + @InnerTestClasses({Class.AccessFlags.class, Class.DeprecatedFlag.class, Class.Visibility.class}) public static class Class extends AbstractWriteFlagsTest { public void testAllFilesPresentInClass() throws Exception { JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("compiler/testData/writeFlags/class"), "kt", true); @@ -102,11 +102,173 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest { } + @TestMetadata("compiler/testData/writeFlags/class/visibility") + @InnerTestClasses({Visibility.Internal.class, Visibility.Private.class, Visibility.Public.class}) + public static class Visibility extends AbstractWriteFlagsTest { + public void testAllFilesPresentInVisibility() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("compiler/testData/writeFlags/class/visibility"), "kt", true); + } + + @TestMetadata("compiler/testData/writeFlags/class/visibility/internal") + public static class Internal extends AbstractWriteFlagsTest { + public void testAllFilesPresentInInternal() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("compiler/testData/writeFlags/class/visibility/internal"), "kt", true); + } + + @TestMetadata("class.kt") + public void testClass() throws Exception { + doTest("compiler/testData/writeFlags/class/visibility/internal/class.kt"); + } + + @TestMetadata("enum.kt") + public void testEnum() throws Exception { + doTest("compiler/testData/writeFlags/class/visibility/internal/enum.kt"); + } + + @TestMetadata("innerClass.kt") + public void testInnerClass() throws Exception { + doTest("compiler/testData/writeFlags/class/visibility/internal/innerClass.kt"); + } + + @TestMetadata("innerEnum.kt") + public void testInnerEnum() throws Exception { + doTest("compiler/testData/writeFlags/class/visibility/internal/innerEnum.kt"); + } + + @TestMetadata("innerObject.kt") + public void testInnerObject() throws Exception { + doTest("compiler/testData/writeFlags/class/visibility/internal/innerObject.kt"); + } + + @TestMetadata("innerTrait.kt") + public void testInnerTrait() throws Exception { + doTest("compiler/testData/writeFlags/class/visibility/internal/innerTrait.kt"); + } + + @TestMetadata("object.kt") + public void testObject() throws Exception { + doTest("compiler/testData/writeFlags/class/visibility/internal/object.kt"); + } + + @TestMetadata("trait.kt") + public void testTrait() throws Exception { + doTest("compiler/testData/writeFlags/class/visibility/internal/trait.kt"); + } + + } + + @TestMetadata("compiler/testData/writeFlags/class/visibility/private") + public static class Private extends AbstractWriteFlagsTest { + public void testAllFilesPresentInPrivate() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("compiler/testData/writeFlags/class/visibility/private"), "kt", true); + } + + @TestMetadata("class.kt") + public void testClass() throws Exception { + doTest("compiler/testData/writeFlags/class/visibility/private/class.kt"); + } + + @TestMetadata("enum.kt") + public void testEnum() throws Exception { + doTest("compiler/testData/writeFlags/class/visibility/private/enum.kt"); + } + + @TestMetadata("innerClass.kt") + public void testInnerClass() throws Exception { + doTest("compiler/testData/writeFlags/class/visibility/private/innerClass.kt"); + } + + @TestMetadata("innerEnum.kt") + public void testInnerEnum() throws Exception { + doTest("compiler/testData/writeFlags/class/visibility/private/innerEnum.kt"); + } + + @TestMetadata("innerObject.kt") + public void testInnerObject() throws Exception { + doTest("compiler/testData/writeFlags/class/visibility/private/innerObject.kt"); + } + + @TestMetadata("innerTrait.kt") + public void testInnerTrait() throws Exception { + doTest("compiler/testData/writeFlags/class/visibility/private/innerTrait.kt"); + } + + @TestMetadata("object.kt") + public void testObject() throws Exception { + doTest("compiler/testData/writeFlags/class/visibility/private/object.kt"); + } + + @TestMetadata("trait.kt") + public void testTrait() throws Exception { + doTest("compiler/testData/writeFlags/class/visibility/private/trait.kt"); + } + + } + + @TestMetadata("compiler/testData/writeFlags/class/visibility/public") + public static class Public extends AbstractWriteFlagsTest { + public void testAllFilesPresentInPublic() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("compiler/testData/writeFlags/class/visibility/public"), "kt", true); + } + + @TestMetadata("class.kt") + public void testClass() throws Exception { + doTest("compiler/testData/writeFlags/class/visibility/public/class.kt"); + } + + @TestMetadata("enum.kt") + public void testEnum() throws Exception { + doTest("compiler/testData/writeFlags/class/visibility/public/enum.kt"); + } + + @TestMetadata("innerClass.kt") + public void testInnerClass() throws Exception { + doTest("compiler/testData/writeFlags/class/visibility/public/innerClass.kt"); + } + + @TestMetadata("innerEnum.kt") + public void testInnerEnum() throws Exception { + doTest("compiler/testData/writeFlags/class/visibility/public/innerEnum.kt"); + } + + @TestMetadata("innerObject.kt") + public void testInnerObject() throws Exception { + doTest("compiler/testData/writeFlags/class/visibility/public/innerObject.kt"); + } + + @TestMetadata("innerTrait.kt") + public void testInnerTrait() throws Exception { + doTest("compiler/testData/writeFlags/class/visibility/public/innerTrait.kt"); + } + + @TestMetadata("object.kt") + public void testObject() throws Exception { + doTest("compiler/testData/writeFlags/class/visibility/public/object.kt"); + } + + @TestMetadata("trait.kt") + public void testTrait() throws Exception { + doTest("compiler/testData/writeFlags/class/visibility/public/trait.kt"); + } + + } + + public static Test innerSuite() { + TestSuite suite = new TestSuite("Visibility"); + suite.addTestSuite(Visibility.class); + suite.addTestSuite(Internal.class); + suite.addTestSuite(Private.class); + suite.addTestSuite(Public.class); + return suite; + } + } + public static Test innerSuite() { TestSuite suite = new TestSuite("Class"); suite.addTestSuite(Class.class); suite.addTestSuite(AccessFlags.class); suite.addTestSuite(DeprecatedFlag.class); + suite.addTest(Visibility.innerSuite()); return suite; } } @@ -194,8 +356,61 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest { } } + @TestMetadata("compiler/testData/writeFlags/innerClass") + @InnerTestClasses({InnerClass.Visibility.class}) + public static class InnerClass extends AbstractWriteFlagsTest { + public void testAllFilesPresentInInnerClass() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("compiler/testData/writeFlags/innerClass"), "kt", true); + } + + @TestMetadata("compiler/testData/writeFlags/innerClass/visibility") + public static class Visibility extends AbstractWriteFlagsTest { + public void testAllFilesPresentInVisibility() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("compiler/testData/writeFlags/innerClass/visibility"), "kt", true); + } + + @TestMetadata("internal.kt") + public void testInternal() throws Exception { + doTest("compiler/testData/writeFlags/innerClass/visibility/internal.kt"); + } + + @TestMetadata("internalClassObject.kt") + public void testInternalClassObject() throws Exception { + doTest("compiler/testData/writeFlags/innerClass/visibility/internalClassObject.kt"); + } + + @TestMetadata("private.kt") + public void testPrivate() throws Exception { + doTest("compiler/testData/writeFlags/innerClass/visibility/private.kt"); + } + + @TestMetadata("privateClassObject.kt") + public void testPrivateClassObject() throws Exception { + doTest("compiler/testData/writeFlags/innerClass/visibility/privateClassObject.kt"); + } + + @TestMetadata("public.kt") + public void testPublic() throws Exception { + doTest("compiler/testData/writeFlags/innerClass/visibility/public.kt"); + } + + @TestMetadata("publicClassObject.kt") + public void testPublicClassObject() throws Exception { + doTest("compiler/testData/writeFlags/innerClass/visibility/publicClassObject.kt"); + } + + } + + public static Test innerSuite() { + TestSuite suite = new TestSuite("InnerClass"); + suite.addTestSuite(InnerClass.class); + suite.addTestSuite(Visibility.class); + return suite; + } + } + @TestMetadata("compiler/testData/writeFlags/property") - @InnerTestClasses({Property.DeprecatedFlag.class}) + @InnerTestClasses({Property.DeprecatedFlag.class, Property.Visibility.class}) public static class Property extends AbstractWriteFlagsTest { public void testAllFilesPresentInProperty() throws Exception { JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("compiler/testData/writeFlags/property"), "kt", true); @@ -219,10 +434,34 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest { } + @TestMetadata("compiler/testData/writeFlags/property/visibility") + public static class Visibility extends AbstractWriteFlagsTest { + public void testAllFilesPresentInVisibility() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("compiler/testData/writeFlags/property/visibility"), "kt", true); + } + + @TestMetadata("internal.kt") + public void testInternal() throws Exception { + doTest("compiler/testData/writeFlags/property/visibility/internal.kt"); + } + + @TestMetadata("private.kt") + public void testPrivate() throws Exception { + doTest("compiler/testData/writeFlags/property/visibility/private.kt"); + } + + @TestMetadata("public.kt") + public void testPublic() throws Exception { + doTest("compiler/testData/writeFlags/property/visibility/public.kt"); + } + + } + public static Test innerSuite() { TestSuite suite = new TestSuite("Property"); suite.addTestSuite(Property.class); suite.addTestSuite(DeprecatedFlag.class); + suite.addTestSuite(Visibility.class); return suite; } } @@ -232,6 +471,7 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest { suite.addTestSuite(WriteFlagsTestGenerated.class); suite.addTest(Class.innerSuite()); suite.addTest(Function.innerSuite()); + suite.addTest(InnerClass.innerSuite()); suite.addTest(Property.innerSuite()); return suite; }