jet.runtime package introduced

compiler/backend/src/org/jetbrains/jet/codegen/JetTypeMapper.java

@@ -60,15 +60,15 @@ public class JetTypeMapper {
     public static final Type TYPE_FUNCTION1 = Type.getObjectType("jet/Function1");
     public static final Type TYPE_ITERATOR = Type.getObjectType("jet/Iterator");
     public static final Type TYPE_INT_RANGE = Type.getObjectType("jet/IntRange");
-    public static final Type TYPE_SHARED_VAR = Type.getObjectType("jet/refs/SharedVar$Object");
+    public static final Type TYPE_SHARED_VAR = Type.getObjectType("jet/runtime/SharedVar$Object");
-    public static final Type TYPE_SHARED_INT = Type.getObjectType("jet/refs/SharedVar$Int");
+    public static final Type TYPE_SHARED_INT = Type.getObjectType("jet/runtime/SharedVar$Int");
-    public static final Type TYPE_SHARED_DOUBLE = Type.getObjectType("jet/refs/SharedVar$Double");
+    public static final Type TYPE_SHARED_DOUBLE = Type.getObjectType("jet/runtime/SharedVar$Double");
-    public static final Type TYPE_SHARED_FLOAT = Type.getObjectType("jet/refs/SharedVar$Float");
+    public static final Type TYPE_SHARED_FLOAT = Type.getObjectType("jet/runtime/SharedVar$Float");
-    public static final Type TYPE_SHARED_BYTE = Type.getObjectType("jet/refs/SharedVar$Byte");
+    public static final Type TYPE_SHARED_BYTE = Type.getObjectType("jet/runtime/SharedVar$Byte");
-    public static final Type TYPE_SHARED_SHORT = Type.getObjectType("jet/refs/SharedVar$Short");
+    public static final Type TYPE_SHARED_SHORT = Type.getObjectType("jet/runtime/SharedVar$Short");
-    public static final Type TYPE_SHARED_CHAR = Type.getObjectType("jet/refs/SharedVar$Char");
+    public static final Type TYPE_SHARED_CHAR = Type.getObjectType("jet/runtime/SharedVar$Char");
-    public static final Type TYPE_SHARED_LONG = Type.getObjectType("jet/refs/SharedVar$Long");
+    public static final Type TYPE_SHARED_LONG = Type.getObjectType("jet/runtime/SharedVar$Long");
-    public static final Type TYPE_SHARED_BOOLEAN = Type.getObjectType("jet/refs/SharedVar$Boolean");
+    public static final Type TYPE_SHARED_BOOLEAN = Type.getObjectType("jet/runtime/SharedVar$Boolean");
 
     public JetTypeMapper(JetStandardLibrary standardLibrary, BindingContext bindingContext) {
         this.standardLibrary = standardLibrary;
@@ -461,7 +461,10 @@ public class JetTypeMapper {
             parameterTypes.add(type);
         }
         for (ValueParameterDescriptor parameter : parameters) {
-            final Type type = mapType(parameter.getOutType());
+            Type type = mapType(parameter.getOutType());
+            if(parameter.isVararg()) {
+                type = Type.getType("[" + type.getDescriptor());
+            }
             valueParameterTypes.add(type);
             parameterTypes.add(type);
         }
@@ -559,7 +562,13 @@ public class JetTypeMapper {
             parameterTypes.add(mapType(receiver.getType()));
         }
         for (ValueParameterDescriptor parameter : parameters) {
-            parameterTypes.add(mapType(parameter.getOutType()));
+            if(parameter.isVararg()) {
+                Type type = mapType(parameter.getOutType());
+                type = Type.getType("[" + type.getDescriptor());
+                parameterTypes.add(type);
+            }
+            else
+                parameterTypes.add(mapType(parameter.getOutType()));
         }
         Type returnType = mapReturnType(f.getReturnType());
         return new Method(name, returnType, parameterTypes.toArray(new Type[parameterTypes.size()]));

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/ArrayIterator.java

@@ -31,31 +31,31 @@ public class ArrayIterator implements IntrinsicMethod {
         JetStandardLibrary standardLibrary = codegen.getState().getStandardLibrary();
         if(containingDeclaration.equals(standardLibrary.getArray())) {
             codegen.generateTypeInfo(funDescriptor.getReturnType().getArguments().get(0).getType());
-            v.invokestatic("jet/arrays/ArrayIterator", "iterator", "([Ljava/lang/Object;Ljet/typeinfo/TypeInfo;)Ljet/Iterator;");
+            v.invokestatic("jet/runtime/ArrayIterator", "iterator", "([Ljava/lang/Object;Ljet/typeinfo/TypeInfo;)Ljet/Iterator;");
         }
         else if(containingDeclaration.equals(standardLibrary.getByteArrayClass())) {
-            v.invokestatic("jet/arrays/ArrayIterator", "iterator", "([B)Ljet/Iterator;");
+            v.invokestatic("jet/runtime/ArrayIterator", "iterator", "([B)Ljet/Iterator;");
         }
         else if(containingDeclaration.equals(standardLibrary.getShortArrayClass())) {
-            v.invokestatic("jet/arrays/ArrayIterator", "iterator", "([S)Ljet/Iterator;");
+            v.invokestatic("jet/runtime/ArrayIterator", "iterator", "([S)Ljet/Iterator;");
         }
         else if(containingDeclaration.equals(standardLibrary.getIntArrayClass())) {
-            v.invokestatic("jet/arrays/ArrayIterator", "iterator", "([I)Ljet/Iterator;");
+            v.invokestatic("jet/runtime/ArrayIterator", "iterator", "([I)Ljet/Iterator;");
         }
         else if(containingDeclaration.equals(standardLibrary.getLongArrayClass())) {
-            v.invokestatic("jet/arrays/ArrayIterator", "iterator", "([J)Ljet/Iterator;");
+            v.invokestatic("jet/runtime/ArrayIterator", "iterator", "([J)Ljet/Iterator;");
         }
         else if(containingDeclaration.equals(standardLibrary.getFloatArrayClass())) {
-            v.invokestatic("jet/arrays/ArrayIterator", "iterator", "([F)Ljet/Iterator;");
+            v.invokestatic("jet/runtime/ArrayIterator", "iterator", "([F)Ljet/Iterator;");
         }
         else if(containingDeclaration.equals(standardLibrary.getDoubleArrayClass())) {
-            v.invokestatic("jet/arrays/ArrayIterator", "iterator", "([D)Ljet/Iterator;");
+            v.invokestatic("jet/runtime/ArrayIterator", "iterator", "([D)Ljet/Iterator;");
         }
         else if(containingDeclaration.equals(standardLibrary.getCharArrayClass())) {
-            v.invokestatic("jet/arrays/ArrayIterator", "iterator", "([C)Ljet/Iterator;");
+            v.invokestatic("jet/runtime/ArrayIterator", "iterator", "([C)Ljet/Iterator;");
         }
         else if(containingDeclaration.equals(standardLibrary.getBooleanArrayClass())) {
-            v.invokestatic("jet/arrays/ArrayIterator", "iterator", "([Z)Ljet/Iterator;");
+            v.invokestatic("jet/runtime/ArrayIterator", "iterator", "([Z)Ljet/Iterator;");
         }
         else {
             throw new UnsupportedOperationException(containingDeclaration.toString());

compiler/tests/org/jetbrains/jet/codegen/VarArgTest.java

@@ -0,0 +1,29 @@
+package org.jetbrains.jet.codegen;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+/**
+ * @author alex.tkachman
+ */
+public class VarArgTest extends CodegenTestCase {
+    public void testStringArray () throws InvocationTargetException, IllegalAccessException {
+        /*
+        loadText("fun test(vararg ts: String) = ts");
+        System.out.println(generateToText());
+        final Method main = generateFunction();
+        Object[] args = {"mama", "papa"};
+        assertTrue(args == main.invoke(null, args));
+        */
+    }
+
+    public void testIntArray () throws InvocationTargetException, IllegalAccessException {
+        /*
+        loadText("fun test(vararg ts: Int) = ts");
+        System.out.println(generateToText());
+        final Method main = generateFunction();
+        int[] args = {3, 4};
+        assertTrue(args == main.invoke(null, args));
+        */
+    }
+}

examples/src/collections/Iterator.kt

@@ -2,6 +2,19 @@ namespace jet.collections
 
 import java.util.NoSuchElementException
 
+trait Iterator<out T> {
+  fun next()  : T
+  val hasNext : Boolean
+
+  fun <R> map(transform: fun(element: T) : R) : Iterator<R> =
+        object : Iterator<R> {
+            override fun next() : R = transform(this@map.next())
+
+            override val hasNext : Boolean
+                get() = this@map.hasNext
+        }
+}
+
 trait ISized {
   val size : Int
 }
@@ -16,6 +29,29 @@ trait ISet<T> : Iterable<T>, ISized {
   fun contains(item : T) : Boolean
 }
 
+trait IList<out T> : Iterable<T>, ISized {
+  fun get(index : Int) : T
+
+  fun iterator() : Iterator<T> =
+    object Iterator<T> {
+        var index = 0
+
+        override fun next() : T = get(index++)
+
+        override val hasNext : Boolean
+           get() = index < size
+    }
+
+  fun toArray() : Array<T> = Array<T>(size) { index => get(index) }
+}
+
+fun <T> Array<T>.asList() : IList<T> = object IList<T> {
+    override val size
+        get() = this@Array.size
+
+    override fun get(index: Int) = this@asList[index]
+}
+
 fun <T> Iterator<T>.foreach(operation: fun(element: T) : Unit)  : Unit = while(hasNext) operation(next())
 
 fun <T> Iterator<T>.foreach(operation: fun(index: Int, element: T) : Unit) : Unit {

stdlib/src/jet/runtime/ArrayIterator.java

@@ -1,13 +1,10 @@
-package jet.arrays;
+package jet.runtime;
 
 import jet.Iterator;
 import jet.JetObject;
 import jet.typeinfo.TypeInfo;
 import jet.typeinfo.TypeInfoProjection;
 
-import java.lang.reflect.GenericArrayType;
-import java.util.Arrays;
-
 /**
  * @author alex.tkachman
  */

stdlib/src/jet/runtime/SharedVar.java

@@ -1,4 +1,4 @@
-package jet.refs;
+package jet.runtime;
 
 public final class SharedVar {
     public static final class Object<T> {