now we use members instead of bunch inner classes, fields and methods

src/org/jetbrains/jet/j2k/Converter.java

@@ -40,13 +40,19 @@ public class Converter {
 
   @NotNull
   public static AnonymousClass anonymousClassToAnonymousClass(@NotNull PsiAnonymousClass anonymousClass) {
-    // TODO: replace by Block, use class.getChild() method
+    return new AnonymousClass(getMembers(anonymousClass));
-    return new AnonymousClass(
+  }
-      classesToClassList(anonymousClass.getAllInnerClasses()),
+
-      methodsToFunctionList(anonymousClass.getMethods()),
+  private static List<Member> getMembers(PsiClass psiClass) {
-      fieldsToFieldList(anonymousClass.getAllFields()),
+    List<Member> members = new LinkedList<Member>();
-      initializersToInitializerList(anonymousClass.getInitializers())
+    for (PsiElement e : psiClass.getChildren()) {
-    );
+      if (e instanceof PsiMethod) members.add(methodToFunction((PsiMethod) e, true));
+      else if (e instanceof PsiField) members.add(fieldToField((PsiField) e));
+      else if (e instanceof PsiClass) members.add(classToClass((PsiClass) e));
+      else if (e instanceof PsiClassInitializer) members.add(initializerToInitializer((PsiClassInitializer) e));
+      else if (e instanceof PsiMember) System.out.println(e.getClass() + " " + e.getText());
+    }
+    return members;
   }
 
   @NotNull
@@ -88,16 +94,15 @@ public class Converter {
   @NotNull
   private static Class classToClass(@NotNull PsiClass psiClass) {
     final Set<String> modifiers = modifiersListToModifiersSet(psiClass.getModifierList());
-    final List<Class> innerClasses = classesToClassList(psiClass.getAllInnerClasses());
-    final List<Function> methods = methodsToFunctionList(psiClass.getMethods());
     final List<Field> fields = fieldsToFieldList(psiClass.getFields());
-    final List<Initializer> anonymousInitializers = initializersToInitializerList(psiClass.getInitializers());
     final List<Element> typeParameters = elementsToElementList(psiClass.getTypeParameters());
     final List<Type> implementsTypes = typesToNotNullableTypeList(psiClass.getImplementsListTypes());
     final List<Type> extendsTypes = typesToNotNullableTypeList(psiClass.getExtendsListTypes());
     final IdentifierImpl name = new IdentifierImpl(psiClass.getName());
     final List<Expression> baseClassParams = new LinkedList<Expression>();
 
+    List<Member> members = getMembers(psiClass);
+
     // we try to find super() call and generate class declaration like that: class A(name: String, i : Int) : Base(name)
     final SuperVisitor visitor = new SuperVisitor();
     psiClass.accept(visitor);
@@ -114,49 +119,52 @@ public class Converter {
       final List<Field> finalOrWithEmptyInitializer = getFinalOrWithEmptyInitializer(fields);
       final Map<String, String> initializers = new HashMap<String, String>();
 
-      for (final Function f : methods) {
+      for (final Member m : members) {
-        for (Field fo : finalOrWithEmptyInitializer) {
-          String init = getDefaultInitializer(fo);
-          initializers.put(fo.getIdentifier().toKotlin(), init);
-        }
-
         // and modify secondaries
-        if (f.getKind() == INode.Kind.CONSTRUCTOR && !((Constructor) f).isPrimary()) {
+        if (m.getKind() == INode.Kind.CONSTRUCTOR) {
-          final List<Statement> newStatements = new LinkedList<Statement>();
+          Function f = (Function)m;
+          if (!((Constructor) f).isPrimary()) {
+            for (Field fo : finalOrWithEmptyInitializer) {
+              String init = getDefaultInitializer(fo);
+              initializers.put(fo.getIdentifier().toKotlin(), init);
+            }
 
-          for (Statement s : f.getBlock().getStatements()) {
+            final List<Statement> newStatements = new LinkedList<Statement>();
-            boolean isRemoved = false;
 
-            if (s.getKind() == INode.Kind.ASSIGNMENT_EXPRESSION) {
+            for (Statement s : f.getBlock().getStatements()) {
-              final AssignmentExpression assignmentExpression = (AssignmentExpression) s;
+              boolean isRemoved = false;
-              if (assignmentExpression.getLeft().getKind() == INode.Kind.CALL_CHAIN) {
+
-                for (Field fo : finalOrWithEmptyInitializer) {
+              if (s.getKind() == INode.Kind.ASSIGNMENT_EXPRESSION) {
-                  final String id = fo.getIdentifier().toKotlin();
+                final AssignmentExpression assignmentExpression = (AssignmentExpression) s;
-                  if (((CallChainExpression) assignmentExpression.getLeft()).getIdentifier().toKotlin().endsWith("." + id)) {
+                if (assignmentExpression.getLeft().getKind() == INode.Kind.CALL_CHAIN) {
-                    initializers.put(id, assignmentExpression.getRight().toKotlin());
+                  for (Field fo : finalOrWithEmptyInitializer) {
-                    isRemoved = true;
+                    final String id = fo.getIdentifier().toKotlin();
+                    if (((CallChainExpression) assignmentExpression.getLeft()).getIdentifier().toKotlin().endsWith("." + id)) {
+                      initializers.put(id, assignmentExpression.getRight().toKotlin());
+                      isRemoved = true;
+                    }
                   }
                 }
               }
+              if (!isRemoved) {
+                newStatements.add(s);
+              }
             }
-            if (!isRemoved) {
+
-              newStatements.add(s);
+            newStatements.add(
-            }
+              0,
+              new DummyStringStatement(
+                "val __ = " + createPrimaryConstructorInvocation(
+                  name.toKotlin(),
+                  finalOrWithEmptyInitializer,
+                  initializers)));
+
+            f.setBlock(new Block(newStatements));
           }
-
-          newStatements.add(
-            0,
-            new DummyStringStatement(
-              "val __ = " + createPrimaryConstructorInvocation(
-                name.toKotlin(),
-                finalOrWithEmptyInitializer,
-                initializers)));
-
-          f.setBlock(new Block(newStatements));
         }
       }
 
-      methods.add(
+      members.add(
         new Constructor(
           Identifier.EMPTY_IDENTIFIER,
           Collections.<String>emptySet(),
@@ -170,18 +178,10 @@ public class Converter {
     }
 
     if (psiClass.isInterface())
-      return new Trait(name, modifiers, typeParameters, extendsTypes, Collections.<Expression>emptyList(), implementsTypes, innerClasses, methods, fields, anonymousInitializers);
+      return new Trait(name, modifiers, typeParameters, extendsTypes, Collections.<Expression>emptyList(), implementsTypes, members);
     if (psiClass.isEnum())
-      return new Enum(name, modifiers, typeParameters, Collections.<Type>emptyList(), Collections.<Expression>emptyList(), implementsTypes,
+      return new Enum(name, modifiers, typeParameters, Collections.<Type>emptyList(), Collections.<Expression>emptyList(), implementsTypes, members);
-        innerClasses, methods, fieldsToFieldListForEnums(psiClass.getAllFields()), anonymousInitializers);
+    return new Class(name, modifiers, typeParameters, extendsTypes, baseClassParams, implementsTypes, members);
-    return new Class(name, modifiers, typeParameters, extendsTypes, baseClassParams, implementsTypes, innerClasses, methods, fields, anonymousInitializers);
-  }
-
-  @NotNull
-  private static List<Initializer> initializersToInitializerList(@NotNull PsiClassInitializer[] initializers) {
-    List<Initializer> result = new LinkedList<Initializer>();
-    for (PsiClassInitializer i : initializers) result.add(initializerToInitializer(i));
-    return result;
   }
 
   @NotNull
@@ -206,31 +206,6 @@ public class Converter {
     }
   }
 
-  // hack for enums, we remove methods:
-  // private int ordinal() { ... }
-  // private String name() { ... }
-  // those methods any enum class inherits from java.lang.Enum
-  @NotNull
-  private static List<Field> fieldsToFieldListForEnums(@NotNull PsiField[] fields) {
-    List<Field> result = new LinkedList<Field>();
-    for (PsiField f : fields) {
-      if ((f.getName().equals("ordinal")
-        && f.getType().getCanonicalText().equals("int")
-        && f.hasModifierProperty(PsiModifier.PRIVATE)
-        && f.hasModifierProperty(PsiModifier.FINAL)
-      ) ||
-        (f.getName().equals("name")
-          && f.getType().getCanonicalText().equals("java.lang.String")
-          && f.hasModifierProperty(PsiModifier.PRIVATE)
-          && f.hasModifierProperty(PsiModifier.FINAL)
-        ))
-        continue;
-
-      result.add(fieldToField(f));
-    }
-    return result;
-  }
-
   @NotNull
   private static List<Field> fieldsToFieldList(@NotNull PsiField[] fields) {
     List<Field> result = new LinkedList<Field>();
@@ -256,13 +231,6 @@ public class Converter {
     );
   }
 
-  @NotNull
-  private static List<Function> methodsToFunctionList(@NotNull PsiMethod[] methods) {
-    List<Function> result = new LinkedList<Function>();
-    for (PsiMethod t : methods) result.add(methodToFunction(t, true));
-    return result;
-  }
-
   @Nullable
   private static PsiMethod getPrimaryConstructorForThisCase(@NotNull PsiClass psiClass) {
     ThisVisitor tv = new ThisVisitor();

src/org/jetbrains/jet/j2k/ast/AnonymousClass.java

@@ -9,17 +9,15 @@ import java.util.List;
  * @author ignatov
  */
 public class AnonymousClass extends Class {
-  public AnonymousClass(List<Class> innerClasses, List<Function> methods, List<Field> fields, List<Initializer> initializers) {
+  public AnonymousClass(List<Member> members) {
     super(new IdentifierImpl("anonClass"),
       Collections.<String>emptySet(),
       Collections.<Element>emptyList(),
       Collections.<Type>emptyList(),
       Collections.<Expression>emptyList(),
       Collections.<Type>emptyList(),
-      innerClasses,
+      members
-      methods,
+    );
-      fields,
-      initializers);
   }
 
   @NotNull

src/org/jetbrains/jet/j2k/ast/Class.java

@@ -18,31 +18,26 @@ public class Class extends Member {
   String TYPE = "class";
   final Identifier myName;
   private final List<Expression> myBaseClassParams;
-  private final List<Initializer> myInitializers;
+  private List<? extends Member> myMembers;
   private final List<Element> myTypeParameters;
   private final List<Type> myExtendsTypes;
   private final List<Type> myImplementsTypes;
-  final List<Class> myInnerClasses;
-  private final List<Function> myMethods;
-  final List<Field> myFields;
 
   public Class(Identifier name, Set<String> modifiers, List<Element> typeParameters, List<Type> extendsTypes,
-               List<Expression> baseClassParams, List<Type> implementsTypes, List<Class> innerClasses, List<Function> methods, List<Field> fields, List<Initializer> initializers) {
+               List<Expression> baseClassParams, List<Type> implementsTypes, List<? extends Member> members) {
     myName = name;
     myBaseClassParams = baseClassParams;
     myModifiers = modifiers;
     myTypeParameters = typeParameters;
     myExtendsTypes = extendsTypes;
     myImplementsTypes = implementsTypes;
-    myInnerClasses = innerClasses;
+    myMembers = members;
-    myMethods = methods;
-    myFields = fields;
-    myInitializers = initializers;
   }
 
+
   @Nullable
   private Constructor getPrimaryConstructor() {
-    for (Function m : myMethods)
+    for (Member m : myMembers)
       if (m.getKind() == Kind.CONSTRUCTOR)
         if (((Constructor) m).isPrimary())
           return (Constructor) m;
@@ -82,9 +77,9 @@ public class Class extends Member {
   }
 
   @NotNull
-  List<Function> methodsExceptConstructors() {
+  LinkedList<Member> membersExceptConstructors() {
-    final LinkedList<Function> result = new LinkedList<Function>();
+    final LinkedList<Member> result = new LinkedList<Member>();
-    for (Function m : myMethods)
+    for (Member m : myMembers)
       if (m.getKind() != Kind.CONSTRUCTOR)
         result.add(m);
     return result;
@@ -93,12 +88,13 @@ public class Class extends Member {
   @NotNull
   List<Function> secondaryConstructorsAsStaticInitFunction() {
     final LinkedList<Function> result = new LinkedList<Function>();
-    for (Function m : myMethods)
+    for (Member m : myMembers)
       if (m.getKind() == Kind.CONSTRUCTOR && !((Constructor) m).isPrimary()) {
+        Function f = (Function) m;
         Set<String> modifiers = new HashSet<String>(m.myModifiers);
         modifiers.add(Modifier.STATIC);
 
-        final List<Statement> statements = m.getBlock().getStatements();
+        final List<Statement> statements = f.getBlock().getStatements();
         statements.add(new ReturnStatement(new IdentifierImpl("__"))); // TODO: move to one place, find other __ usages
         final Block block = new Block(statements);
 
@@ -106,8 +102,8 @@ public class Class extends Member {
           new IdentifierImpl("init"),
           modifiers,
           new ClassType(myName),
-          m.getTypeParameters(),
+          f.getTypeParameters(),
-          m.getParams(),
+          f.getParams(),
           block
         ));
       }
@@ -164,11 +160,8 @@ public class Class extends Member {
 
   String bodyToKotlin() {
     return SPACE + "{" + N +
-      AstUtil.joinNodes(getNonStatic(myFields), N) + N +
+      AstUtil.joinNodes(getNonStatic(membersExceptConstructors()), N) + N +
-      AstUtil.joinNodes(getNonStatic(myInitializers), N) + N +
       classObjectToKotlin() + N +
-      AstUtil.joinNodes(getNonStatic(methodsExceptConstructors()), N) + N +
-      AstUtil.joinNodes(getNonStatic(myInnerClasses), N) + N +
       primaryConstructorBodyToKotlin() + N +
       "}";
   }
@@ -190,17 +183,11 @@ public class Class extends Member {
   }
 
   private String classObjectToKotlin() {
-    final List<Member> staticMethods = new LinkedList<Member>(secondaryConstructorsAsStaticInitFunction());
+    final List<Member> staticMembers = new LinkedList<Member>(secondaryConstructorsAsStaticInitFunction());
-    staticMethods.addAll(getStatic(methodsExceptConstructors()));
+    staticMembers.addAll(getStatic(membersExceptConstructors()));
-    final List<Member> staticFields = getStatic(myFields);
+    if (staticMembers.size() > 0) {
-    final List<Member> staticInitializers = getStatic(myInitializers);
-    final List<Member> staticInnerClasses = getStatic(myInnerClasses);
-    if (staticFields.size() + staticMethods.size() + staticInnerClasses.size() + staticInitializers.size() > 0) {
       return "class" + SPACE + "object" + SPACE + "{" + N +
-        AstUtil.joinNodes(staticFields, N) + N +
+        AstUtil.joinNodes(staticMembers, N) + N +
-        AstUtil.joinNodes(staticInitializers, N) + N +
-        AstUtil.joinNodes(staticMethods, N) + N +
-        AstUtil.joinNodes(staticInnerClasses, N) + N +
         "}";
     }
     return EMPTY;

src/org/jetbrains/jet/j2k/ast/Enum.java

@@ -10,11 +10,12 @@ import java.util.Set;
  * @author ignatov
  */
 public class Enum extends Class {
-  public Enum(Identifier name, Set<String> modifiers, List<Element> typeParameters, List<Type> extendsTypes, List<Expression> baseClassParams, List<Type> implementsTypes, List<Class> innerClasses, List<Function> methods, List<Field> fields, List<Initializer> initializers) {
+  public Enum(Identifier name, Set<String> modifiers, List<Element> typeParameters, List<Type> extendsTypes,
-    super(name, modifiers, typeParameters, extendsTypes, baseClassParams, implementsTypes, innerClasses, methods, fields, initializers);
+              List<Expression> baseClassParams, List<Type> implementsTypes, List<Member> members) {
+    super(name, modifiers, typeParameters, extendsTypes, baseClassParams, implementsTypes, members);
   }
 
-    String primaryConstructorSignatureToKotlin() {
+  String primaryConstructorSignatureToKotlin() {
     String s = super.primaryConstructorSignatureToKotlin();
     return s.equals("()") ? EMPTY : s;
   }
@@ -27,10 +28,9 @@ public class Enum extends Class {
   @NotNull
   @Override
   public String toKotlin() {
-    return modifiersToKotlin() + "enum" + SPACE + myName.toKotlin() + primaryConstructorSignatureToKotlin() + typeParametersToKotlin() + implementTypesToKotlin() + SPACE + "{" + N +
+    return modifiersToKotlin() + "enum" + SPACE + myName.toKotlin() + primaryConstructorSignatureToKotlin() +
-      AstUtil.joinNodes(myFields, N) + N +
+      typeParametersToKotlin() + implementTypesToKotlin() + SPACE + "{" + N +
-      AstUtil.joinNodes(methodsExceptConstructors(), N) + N +
+      AstUtil.joinNodes(membersExceptConstructors(), N) + N +
-      AstUtil.joinNodes(myInnerClasses, N) + N +
       primaryConstructorBodyToKotlin() + N +
       "}";
   }

src/org/jetbrains/jet/j2k/ast/Trait.java

@@ -7,8 +7,9 @@ import java.util.Set;
  * @author ignatov
  */
 public class Trait extends Class {
-  public Trait(Identifier name, Set<String> modifiers, List<Element> typeParameters, List<Type> extendsTypes, List<Expression> baseClassParams, List<Type> implementsTypes, List<Class> innerClasses, List<Function> methods, List<Field> fields, List<Initializer> initializers) {
+  public Trait(Identifier name, Set<String> modifiers, List<Element> typeParameters, List<Type> extendsTypes,
-    super(name, modifiers, typeParameters, extendsTypes, baseClassParams, implementsTypes, innerClasses, methods, fields, initializers);
+               List<Expression> baseClassParams, List<Type> implementsTypes, List<Member> members) {
+    super(name, modifiers, typeParameters, extendsTypes, baseClassParams, implementsTypes, members);
     TYPE = "trait";
   }
 

testData/ast/class/class/oneStaticFieldOneNonStatic.kt

@@ -1,8 +1,8 @@
 class S() {
-class object {
-var myI : Int = 10
-}
 open fun sB() : Boolean {
 return true
 }
+class object {
+var myI : Int = 10
+}
 }

testData/ast/class/class/oneStaticMethodOneNonStatic.kt

@@ -1,10 +1,10 @@
 class S() {
+open fun sB() : Boolean {
+return true
+}
 class object {
 open fun sI() : Int {
 return 1
 }
 }
-open fun sB() : Boolean {
-return true
-}
 }

testData/ast/constructors/file/identifier.kt

@@ -2,6 +2,9 @@ public open class Identifier(myName : String?, myHasDollar : Boolean) {
 private val myName : String?
 private var myHasDollar : Boolean
 private var myNullable : Boolean = true
+open public fun getName() : String? {
+return myName
+}
 class object {
 open public fun init(name : String?) : Identifier {
 val __ = Identifier(name, false)
@@ -18,9 +21,6 @@ __.myNullable = isNullable
 return __
 }
 }
-open public fun getName() : String? {
-return myName
-}
 {
 $myName = myName
 $myHasDollar = myHasDollar