test for unreproducable kt533

compiler/testData/codegen/regressions/kt533.kt

@@ -0,0 +1,134 @@
+namespace mask
+
+import std.io.*
+import java.io.*
+import java.util.*
+
+fun box() : String {
+    val input = StringReader("/Users/abreslav/work/jet/docs/luhnybin/src/test")
+
+    val luhny = Luhny()
+    input.forEachChar {
+        luhny.charIn(it)
+    }
+    luhny.printAll()
+    return "OK"
+
+}
+
+class Luhny() {
+    val buffer = LinkedList<Char>()
+    val digits = LinkedList<Int>()
+
+    var toBeMasked = 0
+
+    fun charIn(it : Char) {
+        buffer.push(it)
+        when (it) {
+            .isDigit() => digits.push(it.int - '0'.int)
+            ' ', '-' => {}
+            else => {
+                    printAll()
+                    digits.clear()
+            }
+        }
+        if (digits.size() > 16)
+          printOneDigit()
+        check()
+    }
+
+    fun check() {
+        if (digits.size() < 14) return
+        val sum = digits.sum { i, d =>
+            if (i % 2 != 0)
+                d * 2 / 10 +  d * 2 % 10
+            else d
+        }
+        if (sum % 10 == 0) toBeMasked = digits.size()
+    }
+
+    fun printOneDigit() {
+        while (!buffer.isEmpty()) {
+            val c = buffer.pop()
+            out(c)
+            if (c.isDigit()) {
+                digits.pop()
+                return
+            }
+        }
+    }
+
+    fun printAll() {
+        while (!buffer.isEmpty())
+          out(buffer.pop())
+    }
+
+    fun out(c : Char) {
+        if (toBeMasked > 0) {
+            print('X')
+            toBeMasked--
+        }
+        else {
+            print(c)
+        }
+    }
+}
+
+fun LinkedList<Int>.sum(f : fun(Int, Int) : Int) : Int {
+    var sum = 0
+    var i = 0
+    for (d in backwards()) {
+        sum += f(i, d)
+        i++
+    }
+    return sum
+}
+
+fun <T> List<T>.backwards() : Iterable<T> = object : Iterable<T> {
+  override fun iterator() : Iterator<T> =
+      object : Iterator<T> {
+          var current = size()
+          override fun next() : T = get(--current)
+          override val hasNext : Boolean get() = current > 0
+      }
+}
+
+fun Char.isDigit() = Character.isDigit(this)
+
+//class Queue<T>(initialBufSize : Int) {
+//
+//    private var bufSize = initialBufSize
+//    private val buf = Array<T>(initialBufSize)
+//    private var head = 0
+//    private var tail = 0
+//    private var size = 0
+//
+//    val empty : Boolean get() = size == 0
+//
+//    private fun prev(i : Int) = (bufSize + i - 1) % bufSize
+//    private fun next(i : Int) = (i + 1) % bufSize
+//
+//    fun push(c : T) {
+//        buf[tail] = c
+//        tail = prev(tail)
+//        size++
+//    }
+//
+//    fun pop() : T {
+//        if (size == 0) throw IllegalStateException()
+//        size--
+//        val result = buf[head]
+//        head = prev(head)
+//        return result
+//    }
+//
+//    fun clear() {}
+//}
+
+fun Reader.forEachChar(body : fun(Char) : Unit) {
+    do {
+        var i = read();
+        if (i == -1) break
+        body(i.chr)
+    } while(true)
+}

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

@@ -73,4 +73,8 @@ public class StdlibTest extends CodegenTestCase {
         blackBoxFile("inputStreamIterator.jet");
         System.out.println(generateToText());
     }
+
+    public void testKt533 () {
+        blackBoxFile("regressions/kt533.kt");
+    }
 }

stdlib/ktSrc/StandardLibrary.kt

@@ -48,8 +48,8 @@ namespace io {
     val InputStream.reader : InputStreamReader
         get() = InputStreamReader(this)
 
-//    val InputStream.bufferedReader : BufferedReader
+    val InputStream.bufferedReader : BufferedReader
-//        get() = buffered.reader
+        get() = BufferedReader(reader)
 
 /*
     inline fun InputStream.reader(charset: Charset) : InputStreamReader  = InputStreamReader(this, charset)
@@ -66,6 +66,8 @@ namespace io {
 
 //    inline fun Reader.buffered(bufferSize: Int) = BufferedReader(this, bufferSize)
 
+//    val String.reader = StringReader(this)
+
     private val stdin : BufferedReader = BufferedReader(InputStreamReader(object : InputStream() {
         override fun read() : Int {
             return System.`in`?.read() ?: -1