Implemented reversed() in proper way.

- converted it into function
- return sequence values
- implemented for sequences as well

compiler/testData/codegen/regressions/kt1076.kt

@@ -4,7 +4,7 @@ fun box() : String {
     cnt++
  }
 
- for (n in (1..5).reversed)
+ for (n in (1..5).reversed())
     cnt++
 
  return if(cnt == 9) "OK" else cnt.toString()

libraries/stdlib/src/kotlin/Ranges.kt

@@ -1,23 +1,59 @@
 package kotlin
 
-public val CharRange.reversed: CharRange
+public fun CharacterSequence.reversed(): CharacterSequence {
-    get() = CharRange(end, if (start < end) -size else size)
+    return CharacterSequence(end, start, -increment)
+}
 
-public val ByteRange.reversed: ByteRange
+public fun ByteSequence.reversed(): ByteSequence {
-    get() = ByteRange(end, if (start < end) -size else size)
+    return ByteSequence(end, start, -increment)
+}
 
-public val ShortRange.reversed: ShortRange
+public fun ShortSequence.reversed(): ShortSequence {
-    get() = ShortRange(end, if (start < end) -size else size)
+    return ShortSequence(end, start, -increment)
+}
 
-public val IntRange.reversed: IntRange
+public fun IntSequence.reversed(): IntSequence {
-    get() = IntRange(end, if (start < end) -size else size)
+    return IntSequence(end, start, -increment)
+}
 
-public val FloatRange.reversed: FloatRange
+public fun FloatSequence.reversed(): FloatSequence {
-    get() = FloatRange(end, if (start < end) -size else size)
+    return FloatSequence(end, start, -increment)
+}
 
-public val LongRange.reversed: LongRange
+public fun LongSequence.reversed(): LongSequence {
-    get() = LongRange(end, if (start < end) -size else size)
+    return LongSequence(end, start, -increment)
+}
+    
+public fun DoubleSequence.reversed(): DoubleSequence {
+    return DoubleSequence(end, start, -increment)
+}
 
-public val DoubleRange.reversed: DoubleRange
+
-    get() = DoubleRange(end, if (start < end) -size else size)
+public fun CharRange.reversed(): CharacterSequence {
+    return CharacterSequence(end, start, -1)
+}
+
+public fun ByteRange.reversed(): ByteSequence {
+    return ByteSequence(end, start, -1)
+}
+
+public fun ShortRange.reversed(): ShortSequence {
+    return ShortSequence(end, start, -1)
+}
+
+public fun IntRange.reversed(): IntSequence {
+    return IntSequence(end, start, -1)
+}
+
+public fun FloatRange.reversed(): FloatSequence {
+    return FloatSequence(end, start, -1.0.toFloat())
+}
+
+public fun LongRange.reversed(): LongSequence {
+    return LongSequence(end, start, -1.toLong())
+}
+    
+public fun DoubleRange.reversed(): DoubleSequence {
+    return DoubleSequence(end, start, -1.0)
+}
 

libraries/stdlib/test/language/RangeTest.kt

@@ -26,20 +26,20 @@ class RangeTest {
 
     test fun reversedRanges() {
         val intRange = 0..9
-        val reversedIntRange = intRange.reversed
+        val reversedIntRange = intRange.reversed()
         assertEquals(10, reversedIntRange.size)
         assertEquals(9, reversedIntRange.start)
         assertEquals(0, reversedIntRange.end)
-        assertEquals(intRange, reversedIntRange.reversed)
+        assertEquals(intRange, reversedIntRange.reversed())
 
         val doubleRange = 0.0..9.0
-        val reversedDoubleRange = doubleRange.reversed
+        val reversedDoubleRange = doubleRange.reversed()
         assertEquals(9.0, reversedDoubleRange.size)
         assertEquals(9.0, reversedDoubleRange.start)
         assertEquals(0.0, reversedDoubleRange.end)
-        assertEquals(doubleRange, reversedDoubleRange.reversed)
+        assertEquals(doubleRange, reversedDoubleRange.reversed())
 
-        assertEquals(IntRange.EMPTY, IntRange.EMPTY.reversed)
+        assertEquals(IntRange.EMPTY, IntRange.EMPTY.reversed())
-        assertEquals(FloatRange.EMPTY, FloatRange.EMPTY.reversed)
+        assertEquals(FloatRange.EMPTY, FloatRange.EMPTY.reversed())
     }
 }