KT-821 and other improvements for ranges

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

@@ -30,7 +30,7 @@ public class RangeTo implements IntrinsicMethod {
             if (JetTypeMapper.isIntPrimitive(leftType)) {
                 codegen.gen(expression.getLeft(), Type.INT_TYPE);
                 codegen.gen(expression.getRight(), Type.INT_TYPE);
-                v.invokestatic("jet/IntRange", "rangeTo", "(II)Ljet/IntRange;");
+                v.invokestatic(expectedType.getInternalName(), "rangeTo", "(" + leftType.getDescriptor() + leftType.getDescriptor() + ")" + expectedType.getDescriptor());
                 return StackValue.onStack(JetTypeMapper.TYPE_INT_RANGE);
             }
             else {

compiler/frontend/src/jet/Library.jet

@@ -238,28 +238,64 @@ trait Range<in T : Comparable<T>> {
   fun contains(item : T) : Boolean
 }
 
-class IntRange(val start : Int, size : Int, reversed : Boolean = false) : Range<Int>, IntIterable {
-    fun iterator () : Iterator<Int>
+class IntRange(val start : Int, val size : Int, val isReversed : Boolean = false) : Range<Int>, IntIterable {
+    fun iterator () : IntIterator
 
     fun contains (elem: Int) : Boolean
 
-    val size : Int
-
     val end : Int
 
-    val reversed : Boolean
+    fun minus() : IntRange
+
+    fun step(step: Int) : IntIterable
 }
 
-class LongRange(val start : Long, size : Long, reversed : Boolean = false) : Range<Long>, Iterable<Long> {
-    fun iterator () : Iterator<Long>
+class LongRange(val start : Long, val size : Long, val isReversed : Boolean = false) : Range<Long>, LongIterable {
+    fun iterator () : LongIterator
 
     fun contains (elem: Long) : Boolean
 
-    val size : Long
-
     val end : Long
 
-    val reversed : Boolean
+    fun minus() : LongRange
+
+    fun step(step: Long) : LongIterable
+}
+
+class ByteRange(val start : Byte, val size : Int, val isReversed : Boolean = false) : Range<Byte>, ByteIterable {
+    fun iterator () : ByteIterator
+
+    fun contains (elem: Byte) : Boolean
+
+    val end : Byte
+
+    fun minus() : ByteRange
+
+    fun step(step: Int) : ByteIterable
+}
+
+class ShortRange(val start : Short, val size : Int, val isReversed : Boolean = false) : Range<Short>, ShortIterable {
+    fun iterator () : ShortIterator
+
+    fun contains (elem: Byte) : Boolean
+
+    val end : Short
+
+    fun minus() : ShortRange
+
+    fun step(step: Int) : ShortIterable
+}
+
+class CharRange(val start : Char, val size : Int, val isReversed : Boolean = false) : Range<Char>, CharIterable {
+    fun iterator () : CharIterator
+
+    fun contains (elem: Char) : Boolean
+
+    val end : Char
+
+    fun minus() : CharRange
+
+    fun step(step: Int) : CharIterable
 }
 
 abstract class Number : Hashable {
@@ -601,7 +637,7 @@ class Char : Number, Comparable<Char> {
   fun rangeTo(other : Int)    : IntRange
   fun rangeTo(other : Short)  : IntRange
   fun rangeTo(other : Byte)   : IntRange
-  fun rangeTo(other : Char)   : IntRange
+  fun rangeTo(other : Char)   : CharRange
 
   fun inc() : Char
   fun dec() : Char
@@ -662,8 +698,8 @@ class Short : Number, Comparable<Short> {
   fun rangeTo(other : Float)  : Range<Float>
   fun rangeTo(other : Long)   : LongRange
   fun rangeTo(other : Int)    : IntRange
-  fun rangeTo(other : Short)  : IntRange
-  fun rangeTo(other : Byte)   : IntRange
+  fun rangeTo(other : Short)  : ShortRange
+  fun rangeTo(other : Byte)   : ShortRange
   fun rangeTo(other : Char)   : IntRange
 
   fun inc() : Short
@@ -725,8 +761,8 @@ class Byte : Number, Comparable<Byte> {
   fun rangeTo(other : Float)  : Range<Float>
   fun rangeTo(other : Long)   : LongRange
   fun rangeTo(other : Int)    : IntRange
-  fun rangeTo(other : Short)  : IntRange
-  fun rangeTo(other : Byte)   : IntRange
+  fun rangeTo(other : Short)  : ShortRange
+  fun rangeTo(other : Byte)   : ByteRange
   fun rangeTo(other : Char)   : IntRange
 
   fun inc() : Byte

compiler/testData/codegen/regressions/kt821.kt

@@ -0,0 +1,51 @@
+fun box() : String {
+    val r1 = IntRange(1, 4)
+    if(r1.end != 4 || r1.isReversed || r1.size != 4) return "fail"
+
+    val r2 = IntRange(1, 4, true)
+    if(r2.end != -2 || !r2.isReversed || r2.size != 4) return "fail"
+
+    val r3 = -(0..5)
+    if(r3.start != 5 || r3.end != 0 || !r3.isReversed || r3.size != 6) return "fail"
+
+    val r4 = -r3
+    if(r4.end != 5 || r4.isReversed || r4.size != 6) return "fail"
+
+    val r5 = ByteRange(1, 4)
+    if(r5.end != 4.byt || r5.isReversed || r5.size != 4) return "fail"
+
+    val r6 = ByteRange(1, 4, true)
+    if(r6.end != -2.byt || !r6.isReversed) return "fail"
+
+    val r7 = -(0.byt..5.byt)
+    if(r7.start != 5.byt || r7.end != 0.byt || !r7.isReversed) return "fail"
+
+    val r9 = -r7
+    if(r9.end != 5.byt || r9.isReversed) return "fail"
+
+    val r10 = ShortRange(1, 4)
+    if(r10.end != 4.sht || r10.isReversed || r10.size != 4) return "fail"
+
+    val r11 = ShortRange(1, 4, true)
+    if(r11.end != -2.sht || !r11.isReversed) return "fail"
+
+    val r12 = -(0.sht..5.sht)
+    if(r12.start != 5.sht || r12.end != 0.sht || !r12.isReversed) return "fail"
+
+    val r13 = -r12
+    if(r13.end != 5.sht || r13.isReversed) return "fail"
+
+    val r14 = CharRange('a', 4)
+    if(r14.end != 'd' || r14.isReversed || r14.size != 4) return "fail"
+
+    val r15 = CharRange('D', 4, true)
+    if(r15.end != 'A' || !r15.isReversed) return "fail"
+
+    val r16 = -('a'..'e')
+    if(r16.start != 'e' || r16.end != 'a' || !r16.isReversed) return "fail"
+
+    val r17 = -r16
+    if(r17.end != 'e' || r17.isReversed) return "fail"
+
+    return "OK"
+}

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

@@ -363,4 +363,8 @@ public class PrimitiveTypesTest extends CodegenTestCase {
     public void testKt887 () {
         blackBoxFile("regressions/kt887.jet");
     }
+
+    public void testKt821 () {
+        blackBoxFile("regressions/kt821.kt");
+    }
 }