Fixed translating primitive arrays to js.

js/js.tests/test/org/jetbrains/k2js/test/semantics/ArraysTest.java

@@ -0,0 +1,26 @@
+/*
+ * Copyright 2010-2013 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.k2js.test.semantics;
+
+import junit.framework.Test;
+
+@SuppressWarnings("JUnitTestCaseWithNoTests")
+public final class ArraysTest extends JsUnitTestBase {
+    public static Test suite() throws Exception {
+        return createTestSuiteForFile("libraries/stdlib/test/ArraysTest.kt");
+    }
+}

js/js.translator/src/org/jetbrains/k2js/translate/intrinsic/functions/factories/ArrayFIF.java

@@ -38,14 +38,39 @@ import static org.jetbrains.k2js.translate.intrinsic.functions.patterns.PatternB
 public final class ArrayFIF extends CompositeFIF {
 
     @NotNull
-    private static final NamePredicate ARRAYS;
+    private static final NamePredicate NUMBER_ARRAY;
 
+    @NotNull
+    private static final NamePredicate CHAR_ARRAY;
+
+    @NotNull
+    private static final NamePredicate BOOLEAN_ARRAY;
+
+    @NotNull
+    private static final NamePredicate ARRAY;
+
+    @NotNull
+    private static final NamePredicate ARRAYS;
     static {
         List<Name> arrayTypeNames = Lists.newArrayList();
-        for (PrimitiveType type : PrimitiveType.values()) {
+        for (PrimitiveType type : PrimitiveType.NUMBER_TYPES) {
-            arrayTypeNames.add(type.getArrayTypeName());
+            if (type != PrimitiveType.CHAR) {
+                arrayTypeNames.add(type.getArrayTypeName());
+            }
         }
-        arrayTypeNames.add(Name.identifier("Array"));
+
+        Name arrayName = Name.identifier("Array");
+        Name booleanArrayName = PrimitiveType.BOOLEAN.getArrayTypeName();
+        Name charArrayName = PrimitiveType.CHAR.getArrayTypeName();
+
+        NUMBER_ARRAY = new NamePredicate(arrayTypeNames);
+        CHAR_ARRAY = new NamePredicate(charArrayName);
+        BOOLEAN_ARRAY = new NamePredicate(booleanArrayName);
+        ARRAY = new NamePredicate(arrayName);
+
+        arrayTypeNames.add(charArrayName);
+        arrayTypeNames.add(booleanArrayName);
+        arrayTypeNames.add(arrayName);
         ARRAYS = new NamePredicate(arrayTypeNames);
     }
 
@@ -91,6 +116,9 @@ public final class ArrayFIF extends CompositeFIF {
         add(pattern(ARRAYS, "<get-size>"), ARRAY_LENGTH_INTRINSIC);
         add(pattern(ARRAYS, "<get-indices>"), new CallStandardMethodIntrinsic(new JsNameRef("arrayIndices", "Kotlin"), true, 0));
         add(pattern(ARRAYS, "iterator"), new CallStandardMethodIntrinsic(new JsNameRef("arrayIterator", "Kotlin"), true, 0));
-        add(pattern(ARRAYS, "<init>"), new CallStandardMethodIntrinsic(new JsNameRef("arrayFromFun", "Kotlin"), false, 2));
+        add(pattern(ARRAY, "<init>"), new CallStandardMethodIntrinsic(new JsNameRef("arrayFromFun", "Kotlin"), false, 2));
+        add(pattern(NUMBER_ARRAY, "<init>"), new CallStandardMethodIntrinsic(new JsNameRef("numberArrayOfSize", "Kotlin"), false, 1));
+        add(pattern(CHAR_ARRAY, "<init>"), new CallStandardMethodIntrinsic(new JsNameRef("charArrayOfSize", "Kotlin"), false, 1));
+        add(pattern(BOOLEAN_ARRAY, "<init>"), new CallStandardMethodIntrinsic(new JsNameRef("booleanArrayOfSize", "Kotlin"), false, 1));
     }
 }

js/js.translator/testFiles/kotlin_lib.js

@@ -499,6 +499,18 @@ var kotlin = {set:function (receiver, key, value) {
         return res;
     };
 
+    Kotlin.numberArrayOfSize = function (size) {
+        return Kotlin.arrayFromFun(size, function(){ return 0; });
+    };
+
+    Kotlin.charArrayOfSize = function (size) {
+        return Kotlin.arrayFromFun(size, function(){ return '\0'; });
+    };
+
+    Kotlin.booleanArrayOfSize = function (size) {
+        return Kotlin.arrayFromFun(size, function(){ return false; });
+    };
+
     Kotlin.arrayFromFun = function (size, initFun) {
         var result = new Array(size);
         for (var i = 0; i < size; i++) {

libraries/stdlib/test/ArraysTest.kt

@@ -33,6 +33,74 @@ class ArraysTest {
         assertEquals("4", arr2[arr2.lastIndex])
     }
 
+    test fun byteArray() {
+        val arr = ByteArray(2)
+
+        val expected: Byte = 0
+        assertEquals(arr.size, 2)
+        assertEquals(expected, arr[0])
+        assertEquals(expected, arr[1])
+    }
+
+    test fun shortArray() {
+        val arr = ShortArray(2)
+
+        val expected: Short = 0
+        assertEquals(arr.size, 2)
+        assertEquals(expected, arr[0])
+        assertEquals(expected, arr[1])
+    }
+
+    test fun intArray() {
+        val arr = IntArray(2)
+
+        assertEquals(arr.size, 2)
+        assertEquals(0, arr[0])
+        assertEquals(0, arr[1])
+    }
+
+    test fun longArray() {
+        val arr = LongArray(2)
+
+        val expected: Long = 0
+        assertEquals(arr.size, 2)
+        assertEquals(expected, arr[0])
+        assertEquals(expected, arr[1])
+    }
+
+    test fun floatArray() {
+        val arr = FloatArray(2)
+
+        val expected: Float = 0.0
+        assertEquals(arr.size, 2)
+        assertEquals(expected, arr[0])
+        assertEquals(expected, arr[1])
+    }
+
+    test fun doubleArray() {
+        val arr = DoubleArray(2)
+
+        assertEquals(arr.size, 2)
+        assertEquals(0.0, arr[0])
+        assertEquals(0.0, arr[1])
+    }
+
+    test fun charArray() {
+        val arr = CharArray(2)
+
+        val expected: Char = '\u0000'
+        assertEquals(arr.size, 2)
+        assertEquals(expected, arr[0])
+        assertEquals(expected, arr[1])
+    }
+
+    test fun booleanArray() {
+        val arr = BooleanArray(2)
+        assertEquals(arr.size, 2)
+        assertEquals(false, arr[0])
+        assertEquals(false, arr[1])
+    }
+
     /*
 
     TODO FIXME ASAP: These currently fail on JS due to missing upto() method on numbers