AnonymousClasses supported

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

@@ -39,10 +39,19 @@ public class Converter {
     return result;
   }
 
-  private static Class classToClass(PsiClass psiClass) {
+  public static AnonymousClass anonymousClassToAnonymousClass(PsiAnonymousClass anonymousClass) { // TODO: replace by Block,
-    final List<Function> methods = methodsToFunctionList(psiClass.getMethods(), true);
+                                                                                                  // use class.getChild() method
+    return new AnonymousClass(
+      classesToClassList(anonymousClass.getAllInnerClasses()),
+      methodsToFunctionList(anonymousClass.getMethods(), true),
+      fieldsToFieldList(anonymousClass.getAllFields())
+    );
+  }
+
+  public static Class classToClass(PsiClass psiClass) {
     final Set<String> modifiers = modifiersListToModifiersSet(psiClass.getModifierList());
     final List<Class> innerClasses = classesToClassList(psiClass.getAllInnerClasses());
+    final List<Function> methods = methodsToFunctionList(psiClass.getMethods(), true);
     final List<Field> fields = fieldsToFieldList(psiClass.getAllFields());
     final List<Element> typeParameters = elementsToElementList(psiClass.getTypeParameters());
     final List<Type> implementsTypes = typesToNotNullableTypeList(psiClass.getImplementsListTypes());

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

@@ -0,0 +1,29 @@
+package org.jetbrains.jet.j2k.ast;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.List;
+
+/**
+ * @author ignatov
+ */
+public class AnonymousClass extends Class {
+  public AnonymousClass(List<Class> innerClasses, List<Function> methods, List<Field> fields) {
+    super(new IdentifierImpl("anonClass"),
+      new HashSet<String>(),
+      new LinkedList<Element>(),
+      new LinkedList<Type>(),
+      new LinkedList<Type>(),
+      innerClasses,
+      methods,
+      fields);
+  }
+
+  @NotNull
+  @Override
+  public String toKotlin() {
+    return bodyToKotlin();
+  }
+}

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

@@ -99,10 +99,11 @@ public class Class extends Member {
   }
 
   String bodyToKotlin() {
-    return classObjectToKotlin() + N +
+    return "{" + N + classObjectToKotlin() + N +
       AstUtil.joinNodes(getNonStatic(myFields), N) + N +
       AstUtil.joinNodes(getNonStatic(methodsExceptConstructors()), N) + N +
-      AstUtil.joinNodes(getNonStatic(myInnerClasses), N) + N;
+      AstUtil.joinNodes(getNonStatic(myInnerClasses), N) + N +
+      "}";
   }
 
   private List<Member> getStatic(List<? extends Member> members) {
@@ -141,8 +142,6 @@ public class Class extends Member {
     return modifiersToKotlin() + TYPE + SPACE + myName.toKotlin() + typeParametersToKotlin() +
       implementTypesToKotlin() +
       typeParameterWhereToKotlin() +
-      SPACE + "{" + N +
+      SPACE + bodyToKotlin();
-      bodyToKotlin() +
-      "}";
   }
 }

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

@@ -1,6 +1,7 @@
 package org.jetbrains.jet.j2k.ast;
 
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 
 /**
  * @author ignatov
@@ -8,15 +9,23 @@ import org.jetbrains.annotations.NotNull;
 public class NewClassExpression extends Expression {
   private final Element myName;
   private final Element myArguments;
+  private AnonymousClass myAnonymousClass = null;
 
   public NewClassExpression(Element name, Element arguments) {
     myName = name;
     myArguments = arguments;
   }
 
+  public NewClassExpression(Element name, Element arguments, @Nullable AnonymousClass anonymousClass) {
+    this(name, arguments);
+    myAnonymousClass = anonymousClass;
+  }
+
   @NotNull
   @Override
   public String toKotlin() {
-    return myName.toKotlin() + "(" + myArguments.toKotlin() + ")";
+    return myAnonymousClass != null ?
+      myName.toKotlin() + "(" + myArguments.toKotlin() + ")" + SPACE + myAnonymousClass.toKotlin() :
+      myName.toKotlin() + "(" + myArguments.toKotlin() + ")";
   }
 }

src/org/jetbrains/jet/j2k/visitors/ExpressionVisitor.java

@@ -4,6 +4,7 @@ import com.intellij.psi.*;
 import com.intellij.psi.impl.source.tree.java.PsiLiteralExpressionImpl;
 import com.intellij.psi.tree.IElementType;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.j2k.Converter;
 import org.jetbrains.jet.j2k.ast.*;
 
 import java.util.List;
@@ -192,7 +193,10 @@ public class ExpressionVisitor extends StatementVisitor implements Visitor {
     } else {
       myResult = new NewClassExpression(
         elementToElement(expression.getClassOrAnonymousClassReference()),
-        elementToElement(expression.getArgumentList())
+        elementToElement(expression.getArgumentList()),
+        expression.getAnonymousClass() != null?
+          anonymousClassToAnonymousClass(expression.getAnonymousClass()) :
+          null
       );
     }
   }

testData/ast/newClassExpression/expression/newClassWithAnonymousScope.jav

@@ -0,0 +1,6 @@
+new Runnable() {
+  @Override
+  public void run() {
+    System.out.println("Run");
+  }
+};

testData/ast/newClassExpression/expression/newClassWithAnonymousScope.kt

@@ -0,0 +1,5 @@
+java.lang.Runnable() {
+override public fun run() : Unit {
+System.`out`?.println("Run")
+}
+}