Back-end: write correct visibility flags for private inner classes

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);

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;
         }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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<? extends Object> aClass = closure.getClass();
-        final Field[] fields = aClass.getFields();
+        final Field[] fields = aClass.getDeclaredFields();
         assertEquals(1, fields.length);
         assertEquals("$s", fields[0].getName());
     }

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;
+        }
+    }
 }

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;
     }