arrays supported more correclty

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

@@ -20,9 +20,9 @@ public class ArrayInitializerExpression extends Expression {
   @NotNull
   private static String createArrayFunction(@NotNull final Type type) {
     String sType = innerTypeStr(type);
-    if (!sType.equals("any") && PRIMITIVE_TYPES.contains(sType))
+    if (PRIMITIVE_TYPES.contains(sType))
-      return sType + "Array";
+      return sType + "Array"; // intArray
-    return AstUtil.lowerFirstCharacter(type.convertedToNotNull().toKotlin());
+    return AstUtil.lowerFirstCharacter(type.convertedToNotNull().toKotlin()); // array<Foo?>
   }
 
   @NotNull

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

@@ -12,6 +12,16 @@ public class ArrayType extends Type {
     myType = type;
   }
 
+  public Type getInnerType() {
+    return myType;
+  }
+
+  @NotNull
+  @Override
+  public Kind getKind() {
+    return Kind.ARRAY_TYPE;
+  }
+
   @NotNull
   @Override
   public String toKotlin() {

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

@@ -0,0 +1,52 @@
+package org.jetbrains.jet.j2k.ast;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.j2k.util.AstUtil;
+
+import java.util.List;
+
+/**
+ * @author ignatov
+ */
+public class ArrayWithoutInitializationExpression extends Expression {
+  private final Type myType;
+  private final List<Expression> myExpressions;
+
+  public ArrayWithoutInitializationExpression(Type type, List<Expression> expressions) {
+    myType = type;
+    myExpressions = expressions;
+  }
+
+  @NotNull
+  @Override
+  public String toKotlin() {
+    if (myType.getKind() == Kind.ARRAY_TYPE) {
+      if (myExpressions.size() == 1)
+        return oneDim(myType, myExpressions.get(0));
+      if (myExpressions.size() == 2) {
+        Type innerType = ((ArrayType) myType).getInnerType();
+        return oneDim(myType, myExpressions.get(0), "{" + SPACE +
+          oneDim(innerType, myExpressions.get(1)) + SPACE + "}");
+      }
+    }
+    return getConstructorName(myType);
+  }
+
+  private static String oneDim(Type type, Expression size) {
+    return oneDim(type, size, EMPTY);
+  }
+
+  private static String oneDim(Type type, Expression size, String init) {
+    String commaWithInit = init.isEmpty() ? EMPTY : COMMA_WITH_SPACE + init;
+    return getConstructorName(type) + "(" + size.toKotlin() + commaWithInit + ")";
+  }
+
+  public static String getConstructorName(Type type) {
+//    if (type instanceof ArrayType) {
+//      String innerTypeStr = ((ArrayType) type).getInnerType().toKotlin().toLowerCase();
+//      if (PRIMITIVE_TYPES.contains(innerTypeStr))
+//        return innerTypeStr + "Array";
+//    }
+    return AstUtil.replaceLastQuest(type.toKotlin());
+  }
+}

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

@@ -13,6 +13,6 @@ public interface INode {
   public Kind getKind();
 
   public enum Kind {
-    UNDEFINED, TYPE, CONSTRUCTOR, BREAK, CONTINUE, VARARG, TRAIT, ASSIGNMENT_EXPRESSION, CALL_CHAIN, LITERAL,
+    UNDEFINED, TYPE, CONSTRUCTOR, BREAK, CONTINUE, VARARG, TRAIT, ASSIGNMENT_EXPRESSION, CALL_CHAIN, LITERAL, ARRAY_TYPE,
   }
 }

src/org/jetbrains/jet/j2k/util/AstUtil.java

@@ -87,4 +87,10 @@ public class AstUtil {
       return map.get(e);
     return orElse;
   }
+
+  public static String replaceLastQuest(String str) {
+    if (str.endsWith("?"))
+      return str.substring(0, str.length() - 1);
+    return str;
+  }
 }

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

@@ -214,11 +214,10 @@ public class ExpressionVisitor extends StatementVisitor {
   @Override
   public void visitNewExpression(@NotNull PsiNewExpression expression) {
     super.visitNewExpression(expression);
-
+    if (expression.getArrayInitializer() != null) // new Foo[] {Foo(1), Foo(2)}
-    if (expression.getArrayInitializer() != null) // new Foo[] {}
       myResult = createNewEmptyArray(expression);
     else if (expression.getArrayDimensions().length > 0) { // new Foo[5]
-      myResult = createNewNonEmptyArray(expression);
+      myResult = createNewEmptyArrayWithoutInitialization(expression);
     } else { // new Class(): common case
       myResult = createNewClassExpression(expression);
     }
@@ -254,12 +253,10 @@ public class ExpressionVisitor extends StatementVisitor {
   }
 
   @NotNull
-  private static NewClassExpression createNewNonEmptyArray(@NotNull PsiNewExpression expression) {
+  private static Expression createNewEmptyArrayWithoutInitialization(@NotNull PsiNewExpression expression) {
-    final List<Expression> callExpression = expressionsToExpressionList(expression.getArrayDimensions());
+    return new ArrayWithoutInitializationExpression(
-    callExpression.add(new IdentifierImpl("{null}")); // TODO: remove
+      typeToType(expression.getType(), true),
-    return new NewClassExpression(
+      expressionsToExpressionList(expression.getArrayDimensions())
-      typeToType(expression.getType()),
-      callExpression
     );
   }
 

testData/ast/arrayType/statement/arrayInitializationStatementWithDimension.kt

@@ -1 +1 @@
-var d2 : Array<IntArray?>? = Array<IntArray?>?(5, {null})
+var d2 : Array<IntArray?>? = Array<IntArray?>(5)

testData/ast/arrayType/statement/arrayInitializationStatementWithDimensionExplicit.jav

@@ -0,0 +1 @@
+int [][] d2 = new int[5][5];

testData/ast/arrayType/statement/d2StringEmptyArray.jav

@@ -0,0 +1 @@
+String [][] ss = new String[5][5];

testData/ast/for/statement/forRangeWithLE.kt

@@ -1,4 +1,4 @@
-var array : IntArray? = IntArray?(10, {null})
+var array : IntArray? = IntArray(10)
 for (i in 0..10) {
 array[i] = i
 }

testData/ast/for/statement/forRangeWithLT.kt

@@ -1,4 +1,4 @@
-var array : IntArray? = IntArray?(10, {null})
+var array : IntArray? = IntArray(10)
 for (i in 0..(10 - 1)) {
 array[i] = i
 }

testData/ast/for/statement/forWithBlock.kt

@@ -1,4 +1,4 @@
-var array : IntArray? = IntArray?(10, {null})
+var array : IntArray? = IntArray(10)
 for (i in 0..(10 - 1)) {
 array[i] = i
 }