obsolete tests deleted

javautil modified
kotlin_lib.js now inside a function
strange bug with js_lib
raphael.kt added

jslib/src/core/annotations.kt

@@ -0,0 +1,7 @@
+package js.annotations;
+
+annotation class NativeClass() {}
+annotation class NativeFun(name : String)
+
+annotation class LibraryClass() {}
+annotation class LibraryFun(name : String) {}

jslib/src/core/core.kt

@@ -1,10 +1,17 @@
 package js;
 
+import js.annotations.LibraryFun
+import js.annotations.LibraryClass
+
+LibraryFun("println")
 fun println()
+LibraryFun("println")
 fun println(s : Any?)
+LibraryFun("print")
 fun print(s : Any?)
-
+LibraryFun("parseInt")
 fun parseInt(s : String) : Int
-
+LibraryClass
 open class Exception()
+LibraryClass
 class NumberFormatException() : Exception()

jslib/src/core/javautil.kt

@@ -1,23 +1,35 @@
 package java.util
 
-import java.lang;
+import js.annotations.*;
-import js.annotations.LibraryClass
+
+//LibraryClass
+//public trait Comparator<T> {
+//    fun compare(obj1 : T, obj2 : T) : Int;
+//}
+//
+//LibraryFun("comparator")
+//public fun comparator<T>(f : (T, T) -> Int) : Comparator<T> {}
+//
+//LibraryFun("max")
+//public fun max<T>(col : Collection<T>, comp : Comparator<T>) {}
+
 
 LibraryClass
-public trait Iterator<T> {
+public open class Iterator<T>() {
-    fun hasNext() : Boolean
+    open fun next() : T {}
-    fun next() : T
+    open fun hasNext() : Boolean {}
 }
 
 LibraryClass
-public open class ArrayList<erased E>() : java.util.List<E>, java.util.AbstractList<E>() {
+public open class ArrayList<erased E>() : java.util.List<E> {
     override public fun size() : Int {}
     override public fun isEmpty() : Boolean {}
     override public fun contains(o : Any?) : Boolean {}
-    override public fun indexOf(o : Any?) : Int {}
+    override public fun iterator() : Iterator<E> {}
-    override public fun lastIndexOf(o : Any?) : Int {}
+   // override public fun indexOf(o : Any?) : Int {}
-    override public fun toArray() : Array<Any?> {}
+  //  override public fun lastIndexOf(o : Any?) : Int {}
-    override public fun toArray<erased T>(a : Array<out T>) : Array<T> {}
+  //  override public fun toArray() : Array<Any?> {}
+  //  override public fun toArray<erased T>(a : Array<out T>) : Array<T> {}
     override public fun get(index : Int) : E {}
     override public fun set(index : Int, element : E) : E {}
     override public fun add(e : E) : Boolean {}
@@ -26,7 +38,7 @@ public open class ArrayList<erased E>() : java.util.List<E>, java.util.AbstractL
     override public fun remove(o : Any?) : Boolean {}
     override public fun clear() : Unit {}
     override public fun addAll(c : java.util.Collection<out E>) : Boolean {}
-    override public fun addAll(index : Int, c : java.util.Collection<out E>) : Boolean {}
+  //  override public fun addAll(index : Int, c : java.util.Collection<out E>) : Boolean {}
 }
 
 LibraryClass
@@ -34,15 +46,15 @@ public trait Collection<erased E> : java.lang.Iterable<E> {
     open fun size() : Int
     open fun isEmpty() : Boolean
     open fun contains(o : Any?) : Boolean
-    override fun iterator() : Iterator<E>
+    override fun iterator() : java.util.Iterator<E>
-    open fun toArray() : Array<Any?>
+   // open fun toArray() : Array<Any?>
-    open fun toArray<erased T>(a : Array<out T>) : Array<T>
+   // open fun toArray<erased T>(a : Array<out T>) : Array<T>
     open fun add(e : E) : Boolean
     open fun remove(o : Any?) : Boolean
-    open fun containsAll(c : java.util.Collection<*>) : Boolean
+    //open fun containsAll(c : java.util.Collection<*>) : Boolean
     open fun addAll(c : java.util.Collection<out E>) : Boolean
-    open fun removeAll(c : java.util.Collection<*>) : Boolean
+    //open fun removeAll(c : java.util.Collection<*>) : Boolean
-    open fun retainAll(c : java.util.Collection<*>) : Boolean
+    //open fun retainAll(c : java.util.Collection<*>) : Boolean
     open fun clear() : Unit
 }
 
@@ -51,56 +63,24 @@ public trait List<erased E> : java.util.Collection<E> {
     override fun size() : Int
     override fun isEmpty() : Boolean
     override fun contains(o : Any?) : Boolean
-    override fun iterator() : Iterator<E>
+    override fun iterator() : java.util.Iterator<E>
-    override fun toArray() : Array<Any?>
+  //  override fun toArray() : Array<Any?>
     // Simulate Java's array covariance
-    override fun toArray<erased T>(a : Array<out T>) : Array<T>
+ //   override fun toArray<erased T>(a : Array<out T>) : Array<T>
     override fun add(e : E) : Boolean
     override fun remove(o : Any?) : Boolean
-    override fun containsAll(c : java.util.Collection<*>) : Boolean
+  //  override fun containsAll(c : java.util.Collection<*>) : Boolean
     override fun addAll(c : java.util.Collection<out E>) : Boolean
-    open fun addAll(index : Int, c : java.util.Collection<out E>) : Boolean
+   // open fun addAll(index : Int, c : java.util.Collection<out E>) : Boolean
-    override fun removeAll(c : java.util.Collection<*>) : Boolean
+   // override fun removeAll(c : java.util.Collection<*>) : Boolean
-    override fun retainAll(c : java.util.Collection<*>) : Boolean
+   // override fun retainAll(c : java.util.Collection<*>) : Boolean
     override fun clear() : Unit
     open fun get(index : Int) : E
     open fun set(index : Int, element : E) : E
     open fun add(index : Int, element : E) : Unit
     open fun remove(index : Int) : E
-    open fun indexOf(o : Any?) : Int
+   // open fun indexOf(o : Any?) : Int
-    open fun lastIndexOf(o : Any?) : Int
+   // open fun lastIndexOf(o : Any?) : Int
-}
-
-LibraryClass
-abstract public class AbstractCollection<erased E> protected () : java.util.Collection<E> {
-    abstract override public fun iterator() : java.util.Iterator<E>
-    abstract override public fun size() : Int
-    override public fun isEmpty() : Boolean {}
-    override public fun contains(o : Any?) : Boolean {}
-    override public fun toArray() : Array<Any?> {}
-    override public fun toArray<erased T>(a : Array<out T>) : Array<T> {}
-    override public fun add(e : E) : Boolean {}
-    override public fun remove(o : Any?) : Boolean {}
-    override public fun containsAll(c : java.util.Collection<*>) : Boolean {}
-    override public fun addAll(c : java.util.Collection<out E>) : Boolean {}
-    override public fun removeAll(c : java.util.Collection<*>) : Boolean {}
-    override public fun retainAll(c : java.util.Collection<*>) : Boolean {}
-    override public fun clear() : Unit {}
-}
-
-LibraryClass
-abstract public open class AbstractList<erased E> protected () : java.util.AbstractCollection<E>(), java.util.List<E> {
-    override public fun add(e : E) : Boolean {}
-    abstract override public fun get(index : Int) : E
-    override public fun set(index : Int, element : E) : E {}
-    override public fun add(index : Int, element : E) : Unit {}
-    override public fun remove(index : Int) : E {}
-    override public fun indexOf(o : Any?) : Int {}
-    override public fun lastIndexOf(o : Any?) : Int {}
-    override public fun clear() : Unit {}
-    override public fun addAll(index : Int, c : java.util.Collection<out E>) : Boolean {}
-    override public fun iterator() : Iterator<E> {}
-    open protected fun removeRange(fromIndex : Int, toIndex : Int) : Unit {}
 }
 
 LibraryClass
@@ -108,38 +88,28 @@ public trait Set<erased E> : java.util.Collection<E> {
     override fun size() : Int
     override fun isEmpty() : Boolean
     override fun contains(o : Any?) : Boolean
-    override fun iterator() : Iterator<E>
+    override fun iterator() : java.util.Iterator<E>
-    override fun toArray() : Array<Any?>
+  //  override fun toArray() : Array<Any?>
-    override fun toArray<erased T>(a : Array<out T>) : Array<T>
+  //  override fun toArray<erased T>(a : Array<out T>) : Array<T>
     override fun add(e : E) : Boolean
     override fun remove(o : Any?) : Boolean
-    override fun containsAll(c : java.util.Collection<*>) : Boolean
+    //override fun containsAll(c : java.util.Collection<*>) : Boolean
     override fun addAll(c : java.util.Collection<out E>) : Boolean
-    override fun retainAll(c : java.util.Collection<*>) : Boolean
+    //override fun retainAll(c : java.util.Collection<*>) : Boolean
-    override fun removeAll(c : java.util.Collection<*>) : Boolean
+    //override fun removeAll(c : java.util.Collection<*>) : Boolean
     override fun clear() : Unit
 }
 
-LibraryClass
-abstract public class AbstractSet<erased E> protected () : java.util.AbstractCollection<E>(), java.util.Set<E> {
-    override public fun removeAll(c : java.util.Collection<*>) : Boolean {}
-}
-
 LibraryClass
 public open class HashSet<erased E>() : java.util.Set<E> {
-    override public fun iterator() : Iterator<E> {}
+    override public fun iterator() : java.util.Iterator<E> {}
     override public fun size() : Int {}
     override public fun isEmpty() : Boolean {}
     override public fun contains(o : Any?) : Boolean {}
     override public fun add(e : E) : Boolean {}
     override public fun remove(o : Any?) : Boolean {}
-    override fun toArray() : Array<Any?> {}
+    override public fun clear() : Unit {}
-    override fun toArray<erased T>(a : Array<out T>) : Array<T> {}
+    override fun addAll(c : java.util.Collection<out E>) : Boolean
-    override fun containsAll(c : java.util.Collection<*>) : Boolean {}
-    override fun addAll(c : java.util.Collection<out E>) : Boolean {}
-    override fun retainAll(c : java.util.Collection<*>) : Boolean {}
-    override fun removeAll(c : java.util.Collection<*>) : Boolean {}
-    override fun clear() : Unit {}
 }
 
 LibraryClass
@@ -148,7 +118,7 @@ public trait Map<erased K, erased V> {
     open fun isEmpty() : Boolean
     open fun containsKey(key : Any?) : Boolean
     open fun containsValue(value : Any?) : Boolean
-    open fun get(key : Any?) : V
+    open fun get(key : Any?) : V?
     open fun put(key : K, value : V) : V?
     open fun remove(key : Any?) : V?
     open fun putAll(m : java.util.Map<out K, out V>) : Unit
@@ -157,28 +127,13 @@ public trait Map<erased K, erased V> {
     open fun values() : java.util.Collection<V>
 }
 
-LibraryClass
-abstract public open class AbstractMap<erased K, erased V> protected () : java.util.Map<K, V> {
-    override public fun size() : Int {}
-    override public fun isEmpty() : Boolean {}
-    override public fun containsValue(value : Any?) : Boolean {}
-    override public fun containsKey(key : Any?) : Boolean {}
-    override public fun get(key : Any?) : V {}
-    override public fun put(key : K, value : V) : V? {}
-    override public fun remove(key : Any?) : V? {}
-    override public fun putAll(m : java.util.Map<out K, out V>) : Unit {}
-    override public fun clear() : Unit {}
-    override public fun keySet() : java.util.Set<K> {}
-    override public fun values() : java.util.Collection<V> {}
-}
-
 LibraryClass
 public open class HashMap<erased K, erased V>() : java.util.Map<K, V> {
     override public fun size() : Int {}
     override public fun isEmpty() : Boolean {}
     override public fun get(key : Any?) : V {}
     override public fun containsKey(key : Any?) : Boolean {}
-    override public fun put(key : K, value : V) : V? {}
+    override public fun put(key : K, value : V) : V {}
     override public fun putAll(m : java.util.Map<out K, out V>) : Unit {}
     override public fun remove(key : Any?) : V? {}
     override public fun clear() : Unit {}
@@ -192,3 +147,4 @@ public class StringBuilder() {
     public fun append(obj : Any) : StringBuilder
     public fun toString() : String
 }
+

jslib/src/core/json.kt

@@ -0,0 +1,11 @@
+package js
+
+import java.util.*;
+
+class Json() {
+    fun set(paramName : String, value : Any?) {}
+    fun get(paramName : String) : Any? = null
+}
+
+fun <K, V> Map<K, V>.toJson() : Json = Json()
+fun json(vararg pairs : Tuple2<String, Any?>) = Json()

jslib/src/jquery/common.kt

@@ -2,17 +2,21 @@ package jquery;
 
 import js.annotations.*;
 
-fun JQuery.toString() = ""
-
 NativeClass
 class JQuery() {
     fun addClass(className : String) : JQuery = this;
     fun addClass(f : DomElement.(Int, String)->String) = this;
-    fun attr(attrName : String) = ""
+
-    fun attr(attrName : String, value : String) = this
+    fun attr(attrName : String) = "";
+    fun attr(attrName : String, value : String) = this;
+
+    fun html() : String = "";
+    fun html(s : String) = this;
+    fun html(f : DomElement.(Int, String)->String) = this;
+
+
     fun hasClass(className : String) = true
     fun removeClass(className : String) = this
-    fun html() : String = ""
     fun height() = 0
     fun width() = 0
     fun click() = this;

jslib/src/raphael/raphael.kt

@@ -0,0 +1,34 @@
+package raphael
+
+import js.annotations.*;
+import js.*;
+
+NativeClass
+class Element() {
+
+    fun attr(name : String, value : String) : Element = this
+    fun attr(nameToValue : Json) : Element = this
+
+    fun mouseover(handler : () -> Unit) = this
+
+    fun getTotalLength() : Double = 0.0
+    //fun mouse
+}
+
+NativeClass
+class Paper() {
+    fun path(pathString : String) : Element = Element();
+    fun path() : Element = Element();
+
+    fun ellipse(x : Int, y : Int, rx : Int, ry : Int) : Element = Element();
+}
+
+NativeFun("Raphael")
+fun Raphael(elementId : String, width : Int, height : Int) : Paper = Paper();
+NativeFun("Raphael")
+fun Raphael(elementId : String, width : Int, height : Int, initFun : Paper.() -> Unit) : Unit {}
+
+NativeClass
+val Raphael = object {
+    fun getColor() : String = ""
+}

translator/src/org/jetbrains/k2js/config/Config.java

@@ -28,7 +28,9 @@ public abstract class Config {
             PATH_TO_JS_LIB_SRC + "\\jquery\\common.kt",
             PATH_TO_JS_LIB_SRC + "\\core\\javautil.kt",
             PATH_TO_JS_LIB_SRC + "\\core\\javalang.kt",
-            PATH_TO_JS_LIB_SRC + "\\core\\core.kt"
+            PATH_TO_JS_LIB_SRC + "\\core\\core.kt",
+            PATH_TO_JS_LIB_SRC + "\\raphael\\raphael.kt",
+            PATH_TO_JS_LIB_SRC + "\\core\\json.kt"
     );
 
 

translator/test/org/jetbrains/k2js/test/KotlinLibTest.java

@@ -2,7 +2,6 @@ package org.jetbrains.k2js.test;
 
 import org.junit.Test;
 import org.mozilla.javascript.Context;
-import org.mozilla.javascript.Function;
 import org.mozilla.javascript.Scriptable;
 
 import java.util.Arrays;
@@ -38,29 +37,6 @@ public class KotlinLibTest extends TranslationTest {
 
     //TODO: refactor
 
-    @Test
-    public void classObjectHasCreateMethod() throws Exception {
-        final Map<String, Class<? extends Scriptable>> propertyToType
-                = new HashMap<String, Class<? extends Scriptable>>();
-        propertyToType.put("create", Function.class);
-        runPropertyTypeCheck("Class", propertyToType);
-    }
-
-    @Test
-    public void namespaceObjectHasCreateMethod() throws Exception {
-        final Map<String, Class<? extends Scriptable>> propertyToType
-                = new HashMap<String, Class<? extends Scriptable>>();
-        propertyToType.put("create", Function.class);
-        runPropertyTypeCheck("Namespace", propertyToType);
-    }
-
-    @Test
-    public void traitObjectHasCreateMethod() throws Exception {
-        final Map<String, Class<? extends Scriptable>> propertyToType
-                = new HashMap<String, Class<? extends Scriptable>>();
-        propertyToType.put("create", Function.class);
-        runPropertyTypeCheck("Trait", propertyToType);
-    }
 
     @Test
     public void createdTraitIsJSObject() throws Exception {

translator/test/org/jetbrains/k2js/test/StdlibTest.java

@@ -1,7 +1,5 @@
 package org.jetbrains.k2js.test;
 
-import org.junit.Test;
-
 /**
  * @author Pavel Talanov
  */
@@ -13,9 +11,9 @@ public final class StdlibTest extends TranslationTest {
         return MAIN;
     }
 
-    //TODO: test!
+    //TODO: cant do due to big java dependencies
-    @Test
+//    @Test
-    public void filter() throws Exception {
+//    public void filter() throws Exception {
-        // testFooBoxIsTrue("Filter.kt");
+//         testFooBoxIsTrue("Filter.kt");
-    }
+//    }
 }

translator/test/org/jetbrains/k2js/test/WebDemoExamples2Test.java

@@ -20,7 +20,7 @@ public final class WebDemoExamples2Test extends TranslationTest {
         testWithMain("bottles", "");
     }
 
-    //TODO: a couple of classes not supported
+    //TODO: a couple of classes not supported and objects
 //    @Test
 //    public void life() throws Exception {
 //        testWithMain("life", "", "2");
@@ -31,4 +31,10 @@ public final class WebDemoExamples2Test extends TranslationTest {
         testWithMain("builder", "");
         testWithMain("builder", "1", "over9000");
     }
+
+    //TODO: comparator dependencies
+//    @Test
+//    public void maze() throws Exception {
+//        testWithMain("maze", "");
+//    }
 }

translator/testFiles/java/arrayList/cases/max.kt

@@ -0,0 +1,8 @@
+package foo
+
+import java.util.Collection;
+import java.util.Comparator.
+
+fun max<T>(col :Collection<T>, ) {
+
+}

translator/testFiles/kotlinLib/cases/isAncestorType.js

@@ -1,7 +1,7 @@
-var A = Class.create();
+var A = Kotlin.Class.create();
-var B = Class.create(A);
+var B = Kotlin.Class.create(A);
 var b = new B;
 
 test = function() {
-    return (isType(b, A) && isType(b, B));
+    return (Kotlin.isType(b, A) && Kotlin.isType(b, B));
 }

translator/testFiles/kotlinLib/cases/isComplexTest.js

@@ -1,22 +1,22 @@
-var A = Class.create();
+var A = Kotlin.Class.create();
-var B = Class.create(A);
+var B = Kotlin.Class.create(A);
 var b = new B;
-var C = Class.create(B);
+var C = Kotlin.Class.create(B);
 var c = new C;
-var E = Class.create(A)
+var E = Kotlin.Class.create(A)
 var e = new E;
 
 test1 = function() {
     b2 = b
-    return (isType(b, A) && isType(b, B));
+    return (Kotlin.isType(b, A) && Kotlin.isType(b, B));
 }
 
 test2 = function() {
-    return (isType(c, C) && isType(c, B) && isType(c, A) && (!isType(c, E)));
+    return (Kotlin.isType(c, C) && Kotlin.isType(c, B) && Kotlin.isType(c, A) && (!Kotlin.isType(c, E)));
 }
 
 test3 = function() {
-    return isType(e, E) && !isType(e, B) && !isType(e, C) && isType(e, A)
+    return Kotlin.isType(e, E) && !Kotlin.isType(e, B) && !Kotlin.isType(e, C) && Kotlin.isType(e, A)
 }
 
 test = function() {

translator/testFiles/kotlinLib/cases/isNotOtherType.js

@@ -1,6 +1,6 @@
-var A = Class.create();
+var A = Kotlin.Class.create();
-var B = Class.create(A);
+var B = Kotlin.Class.create(A);
-var C = Class.create();
+var C = Kotlin.Class.create();
 var c = new C;
 
 test = function() {

translator/testFiles/kotlinLib/cases/isSameType.js

@@ -1,6 +1,6 @@
-var A = Class.create();
+var A = Kotlin.Class.create();
 var a = new A;
 
 test = function() {
-    return isType(a, A);
+    return Kotlin.isType(a, A);
 }

translator/testFiles/kotlinLib/cases/namespace.js

@@ -1,4 +1,4 @@
-foo = Namespace.create({initialize:function(){
+foo = Kotlin.Namespace.create({initialize:function(){
 }
 , box:function(){
   return !false;

translator/testFiles/kotlinLib/cases/namespaceWithClasses.js

@@ -1,6 +1,6 @@
 {
   classes = function(){
-    var A = Class.create({initialize:function(){
+    var A = Kotlin.Class.create({initialize:function(){
       this.$order = '';
       {
         this.set_order(this.get_order() + 'A');
@@ -13,14 +13,14 @@
       return this.$order;
     }
     });
-    var B = Class.create(A, {initialize:function(){
+    var B = Kotlin.Class.create(A, {initialize:function(){
       this.super_init();
       {
         this.set_order(this.get_order() + 'B');
       }
     }
     });
-    var C = Class.create(B, {initialize:function(){
+    var C = Kotlin.Class.create(B, {initialize:function(){
       this.super_init();
       {
         this.set_order(this.get_order() + 'C');
@@ -30,7 +30,7 @@
     return {A:A, B:B, C:C};
   }
   ();
-  foo = Namespace.create(classes, {initialize:function(){
+  foo = Kotlin.Namespace.create(classes, {initialize:function(){
   }
   , box:function(){
     return (new foo.C).get_order() === 'ABC' && (new foo.B).get_order() === 'AB' && (new foo.A).get_order() === 'A';
@@ -38,8 +38,6 @@
   });
 }
 
-
-
 function test() {
     return foo.box()
 }

translator/testFiles/kotlinLib/cases/trait.js

@@ -1,10 +1,10 @@
 foo = {};
 (function(foo){
-  foo.Test = Trait.create({addFoo:function(s){
+  foo.Test = Kotlin.Trait.create({addFoo:function(s){
     return s + 'FOO';
   }
   });
-  foo.ExtendedTest = Trait.create(foo.Test, {hooray:function(){
+  foo.ExtendedTest = Kotlin.Trait.create(foo.Test, {hooray:function(){
     return 'hooray';
   }
   });

translator/testFiles/stdlib/cases/Filter.kt

@@ -1,19 +1,17 @@
-package foo
+package std
 
-import js.*
 import java.util.*
-
+import java.lang.Iterable
-class NoSuchElementException() : Exception() {}
 
 /*
 Filters given iterator
 */
-inline fun <T> Iterator<T>.filter(f: (T)-> Boolean) : Iterator<T> = FilterIterator<T>(this, f)
+inline fun <T> java.util.Iterator<T>.filter(f: (T)-> Boolean) : java.util.Iterator<T> = FilterIterator<T>(this, f)
 
 /*
 Adds filtered elements in to given container
 */
-inline fun <T,U : Collection<in T>> Iterable<T>.filterTo(var container: U, filter: (T)->Boolean) : U {
+inline fun <T,U : Collection<in T>> java.lang.Iterable<T>.filterTo(var container: U, filter: (T)->Boolean) : U {
    for(element in this) {
       if(filter(element))
         container.add(element)
@@ -25,37 +23,38 @@ inline fun <T,U : Collection<in T>> Iterable<T>.filterTo(var container: U, filte
 Create iterator filtering given java.lang.Iterable
 */
 /*
-inline fun <T> Iterable<T>.filter(f: (T)->Boolean) : Iterator<T> = (iterator() as Iterator<T>).filter(f)
+inline fun <T> java.lang.Iterable<T>.filter(f: (T)->Boolean) : java.util.Iterator<T> = (iterator() as java.util.Iterator<T>).filter(f)
 */
 
-private class FilterIterator<T>(val original: Iterator<T>, val filter: (T)-> Boolean) : Iterator<T> {
+private class FilterIterator<T>(val original: java.util.Iterator<T>, val filter: (T)-> Boolean) : java.util.Iterator<T> {
     var state = 0
     var nextElement: T? = null
 
-    override val hasNext: Boolean
+    override fun hasNext(): Boolean =
-    get() {
+        when(state) {
-      if (state == 1) {
+                1 -> true  // checked and next present
-          return true;
+                2 -> false // checked and next not present
-      }
+                else -> {
-      if (state == 2) {
+                    while(original.hasNext()) {
-          return false;
+                        val candidate = original.next()
-      }
+                        if((filter)(candidate)) {
-      while(original.hasNext) {
+                            nextElement = candidate
-         val candidate = original.next()
+                            state = 1
-          if((filter)(candidate)) {
+                            true
-              nextElement = candidate
+                        }
-              state = 1;
+                    }
-              return true;
+                    state = 2
-          }
+                    false
-      }
+                }
-        state = 2;
+        }
-        return false;
-    }
 
-    override fun next(): T {
+    override fun next(): T =
+        if(state != 1)
+            throw java.util.NoSuchElementException()
+        else {
             val res = nextElement as T
             nextElement = null
             state = 0
-            return res
+            res
         }
 }

translator/testFiles/webDemoExamples2/cases/maze.kt

@@ -0,0 +1,238 @@
+/**
+ * Let's Walk Through a Maze.
+ *
+ * Imagine there is a maze whose walls are the big 'O' letters.
+ * Now, I stand where a big 'I' stands and some cool prize lies
+ * somewhere marked with a '$' sign. Like this:
+ *
+ *    OOOOOOOOOOOOOOOOO
+ *    O               O
+ *    O$  O           O
+ *    OOOOO           O
+ *    O               O
+ *    O  OOOOOOOOOOOOOO
+ *    O           O I O
+ *    O               O
+ *    OOOOOOOOOOOOOOOOO
+ *
+ * I want to get the prize, and this program helps me do so as soon
+ * as I possibly can by finding a shortest path through the maze.
+ */
+package maze
+
+import java.util.Collections.*
+import java.util.*
+
+/**
+ * This function looks for a path from max.start to maze.end through
+ * free space (a path does not go through walls). One can move only
+ * straightly up, down, left or right, no diagonal moves allowed.
+ */
+fun findPath(maze : Maze) : List<#(Int, Int)>? {
+    val previous = HashMap<#(Int, Int), #(Int, Int)>
+
+    val queue = LinkedList<#(Int, Int)>
+    val visited = HashSet<#(Int, Int)>
+
+    queue.offer(maze.start)
+    visited.add(maze.start)
+    while (!queue.isEmpty()) {
+      val cell = queue.poll()
+      if (cell == maze.end) break
+
+      for (newCell in maze.neighbors(cell._1, cell._2)) {
+        if (newCell in visited) continue
+        previous[newCell] = cell
+        queue.offer(newCell)
+        visited.add(cell)
+      }
+    }
+
+    if (previous[maze.end] == null) return null
+
+    val path = ArrayList<#(Int, Int)>()
+    var current = previous[maze.end]
+    while (current != maze.start) {
+        path.add(0, current)
+        current = previous[current]
+    }
+    return path
+}
+
+/**
+ * Find neighbors of the (i, j) cell that are not walls
+ */
+fun Maze.neighbors(i : Int, j : Int) : List<#(Int, Int)> {
+  val result = ArrayList<#(Int, Int)>
+  addIfFree(i - 1, j, result)
+  addIfFree(i, j - 1, result)
+  addIfFree(i + 1, j, result)
+  addIfFree(i, j + 1, result)
+  return result
+}
+
+fun Maze.addIfFree(i : Int, j : Int, result : List<#(Int, Int)>) {
+  if (i !in 0..height-1) return
+  if (j !in 0..width-1) return
+  if (walls[i][j]) return
+
+  result.add(#(i, j))
+}
+
+/**
+ * A data class that represents a maze
+ */
+class Maze(
+    // Number or columns
+    val width : Int,
+    // Number of rows
+    val height : Int,
+    // true for a wall, false for free space
+    val walls : Array<out Array<out Boolean>>,
+    // The starting point (must not be a wall)
+    val start : #(Int, Int),
+    // The target point (must not be a wall)
+    val end : #(Int, Int)
+) {
+}
+
+/** A few maze examples here */
+fun main(args : Array<String>) {
+  printMaze("I  $")
+  printMaze("I O $")
+  printMaze("""
+    O  $
+    O
+    O
+    O
+    O           I
+  """)
+  printMaze("""
+    OOOOOOOOOOO
+    O $       O
+    OOOOOOO OOO
+    O         O
+    OOOOO OOOOO
+    O         O
+    O OOOOOOOOO
+    O        OO
+    OOOOOO   IO
+  """)
+  printMaze("""
+    OOOOOOOOOOOOOOOOO
+    O               O
+    O$  O           O
+    OOOOO           O
+    O               O
+    O  OOOOOOOOOOOOOO
+    O           O I O
+    O               O
+    OOOOOOOOOOOOOOOOO
+  """)
+}
+
+// UTILITIES
+
+fun printMaze(str : String) {
+    val maze = makeMaze(str)
+
+    println("Maze:")
+    val path = findPath(maze)
+    for (i in 0..maze.height - 1) {
+        for (j in 0..maze.width - 1) {
+            val cell = #(i, j)
+            print(
+                if (maze.walls[i][j]) "O"
+                else if (cell == maze.start) "I"
+                else if (cell == maze.end) "$"
+                else if (path != null && path.contains(cell)) "~"
+                else " "
+            )
+        }
+        println("")
+    }
+    println("Result: " + if (path == null) "No path" else "Path found")
+    println("")
+}
+
+/**
+ * A maze is encoded in the string s: the big 'O' letters are walls.
+ * I stand where a big 'I' stands and the prize is marked with
+ * a '$' sign.
+ *
+ * Example:
+ *
+ *    OOOOOOOOOOOOOOOOO
+ *    O               O
+ *    O$  O           O
+ *    OOOOO           O
+ *    O               O
+ *    O  OOOOOOOOOOOOOO
+ *    O           O I O
+ *    O               O
+ *    OOOOOOOOOOOOOOOOO
+ */
+fun makeMaze(s : String) : Maze {
+  val lines = s.split("\n").sure()
+  val w = max<String?>(lines.toList(), comparator<String?> {o1, o2 ->
+          val l1 : Int = o1?.size ?: 0
+          val l2 = o2?.size ?: 0
+          l1 - l2
+  }).sure()
+  val data = Array<Array<Boolean>>(lines.size) {Array<Boolean>(w.size) {false}}
+
+  var start : #(Int, Int)? = null
+  var end : #(Int, Int)? = null
+
+  for (line in lines.indices) {
+    for (x in lines[line].indices) {
+      val c = lines[line].sure()[x]
+      data[line][x] = c == 'O'
+      when (c) {
+        'I' -> start = #(line, x)
+        '$' -> end = #(line, x)
+        else -> {}
+      }
+    }
+  }
+
+  if (start == null) {
+      throw IllegalArgumentException("No starting point in the maze (should be indicated with 'I')")
+  }
+
+  if (end == null) {
+      throw IllegalArgumentException("No goal point in the maze (should be indicated with a '$' sign)")
+  }
+
+  return Maze(w.size, lines.size, data, start.sure(), end.sure())
+}
+
+// An excerpt from the Standard Library
+val String?.indices : IntRange get() = IntRange(0, this.sure().size)
+
+val String.size : Int
+  get() = length
+
+fun <K, V> Map<K, V>.set(k : K, v : V) { put(k, v) }
+
+fun comparator<T> (f : (T, T) -> Int) : Comparator<T> = object : Comparator<T> {
+    override fun compare(o1 : T, o2 : T) : Int = f(o1, o2)
+}
+
+fun String.split(s : String)  = (this as java.lang.String).split(s)
+
+fun println(message : Any?) {
+    System.out?.println(message)
+}
+
+fun print(message : Any?) {
+    System.out?.print(message)
+}
+
+fun <T, C: Collection<T>> Array<T>.to(result: C) : C {
+  for (elem in this)
+    result.add(elem)
+  return result
+}
+
+fun <T> Array<T>.toList() : List<T> = this.to(ArrayList<T>())

translator/testFiles/webDemoExamples2/expected/maze.out

@@ -0,0 +1,45 @@
+Maze:
+I~~$
+Result: Path found
+
+Maze:
+I O $
+Result: No path
+
+Maze:
+
+O $
+O ~
+O ~
+O ~
+O ~~~~~~~~~I
+
+Result: Path found
+
+Maze:
+
+OOOOOOOOOOO
+O $~~~~~ O
+OOOOOOO~OOO
+O ~~~ O
+OOOOO~OOOOO
+O~~~~~ O
+O~OOOOOOOOO
+O~~~~~~ OO
+OOOOOO~~~IO
+
+Result: Path found
+
+Maze:
+
+OOOOOOOOOOOOOOOOO
+O ~~~ O
+O$~~O~ O
+OOOOO~ O
+O ~~~~ O
+O ~OOOOOOOOOOOOOO
+O ~ O I O
+O ~~~~~~~~~~~~~ O
+OOOOOOOOOOOOOOOOO
+
+Result: Path found