diff --git a/compiler/testData/builtin-classes.txt b/compiler/testData/builtin-classes.txt
index 818c4229dc4..c26a76e9f03 100644
--- a/compiler/testData/builtin-classes.txt
+++ b/compiler/testData/builtin-classes.txt
@@ -147,14 +147,13 @@ public abstract class ByteIterator : jet.Iterator<jet.Byte> {
     public abstract fun nextByte() : jet.Byte
 }
 
-public final class ByteRange : jet.Range<jet.Byte>, jet.ByteIterable {
-    public constructor ByteRange(/*0*/ start : jet.Byte, /*1*/ size : jet.Int)
-    public final val end : jet.Byte
-    public final val size : jet.Int
-    public final val start : jet.Byte
+public final class ByteRange : jet.Range<jet.Byte>, jet.NumberSequence<jet.Byte>, jet.ByteIterable {
+    public constructor ByteRange(/*0*/ start : jet.Byte, /*1*/ end : jet.Byte)
+    public open override /*2*/ val end : jet.Byte
+    public open override /*1*/ val increment : jet.Int
+    public open override /*2*/ val start : jet.Byte
     public open override /*1*/ fun contains(/*0*/ elem : jet.Byte) : jet.Boolean
-    public open override /*1*/ fun iterator() : jet.ByteIterator
-    public final fun step(/*0*/ step : jet.Int) : jet.ByteIterator
+    public open override /*2*/ fun iterator() : jet.ByteIterator
     
     public class object <class-object-for-ByteRange> {
         private constructor <class-object-for-ByteRange>()
@@ -162,6 +161,14 @@ public final class ByteRange : jet.Range<jet.Byte>, jet.ByteIterable {
     }
 }
 
+public final class ByteSequence : jet.NumberSequence<jet.Byte> {
+    public constructor ByteSequence(/*0*/ start : jet.Byte, /*1*/ end : jet.Byte, /*2*/ increment : jet.Int)
+    public open override /*1*/ val end : jet.Byte
+    public open override /*1*/ val increment : jet.Int
+    public open override /*1*/ val start : jet.Byte
+    public open override /*1*/ fun iterator() : jet.ByteIterator
+}
+
 public final class Char : jet.Number, jet.Comparable<jet.Char> {
     public constructor Char()
     public final fun compareTo(/*0*/ other : jet.Byte) : jet.Int
@@ -238,14 +245,13 @@ public abstract class CharIterator : jet.Iterator<jet.Char> {
     public abstract fun nextChar() : jet.Char
 }
 
-public final class CharRange : jet.Range<jet.Char>, jet.CharIterable {
-    public constructor CharRange(/*0*/ start : jet.Char, /*1*/ size : jet.Int)
-    public final val end : jet.Char
-    public final val size : jet.Int
-    public final val start : jet.Char
+public final class CharRange : jet.Range<jet.Char>, jet.NumberSequence<jet.Char>, jet.CharIterable {
+    public constructor CharRange(/*0*/ start : jet.Char, /*1*/ end : jet.Char)
+    public open override /*2*/ val end : jet.Char
+    public open override /*1*/ val increment : jet.Int
+    public open override /*2*/ val start : jet.Char
     public open override /*1*/ fun contains(/*0*/ elem : jet.Char) : jet.Boolean
-    public open override /*1*/ fun iterator() : jet.CharIterator
-    public final fun step(/*0*/ step : jet.Int) : jet.CharIterator
+    public open override /*2*/ fun iterator() : jet.CharIterator
     
     public class object <class-object-for-CharRange> {
         private constructor <class-object-for-CharRange>()
@@ -259,6 +265,14 @@ public trait CharSequence {
     public abstract fun toString() : jet.String
 }
 
+public final class CharacterSequence : jet.NumberSequence<jet.Char> {
+    public constructor CharacterSequence(/*0*/ start : jet.Char, /*1*/ end : jet.Char, /*2*/ increment : jet.Int)
+    public open override /*1*/ val end : jet.Char
+    public open override /*1*/ val increment : jet.Int
+    public open override /*1*/ val start : jet.Char
+    public open override /*1*/ fun iterator() : jet.CharIterator
+}
+
 public trait Collection</*0*/ out E> : jet.Iterable<E>, jet.Hashable {
     public abstract fun contains(/*0*/ o : jet.Any?) : jet.Boolean
     public abstract fun containsAll(/*0*/ c : jet.Collection<jet.Any?>) : jet.Boolean
@@ -360,13 +374,13 @@ public abstract class DoubleIterator : jet.Iterator<jet.Double> {
     public abstract fun nextDouble() : jet.Double
 }
 
-public final class DoubleRange : jet.Range<jet.Double> {
-    public constructor DoubleRange(/*0*/ start : jet.Double, /*1*/ size : jet.Double)
-    public final val end : jet.Double
-    public final val size : jet.Double
-    public final val start : jet.Double
+public final class DoubleRange : jet.Range<jet.Double>, jet.NumberSequence<jet.Double>, jet.DoubleIterable {
+    public constructor DoubleRange(/*0*/ start : jet.Double, /*1*/ end : jet.Double)
+    public open override /*2*/ val end : jet.Double
+    public open override /*1*/ val increment : jet.Double
+    public open override /*2*/ val start : jet.Double
     public open override /*1*/ fun contains(/*0*/ elem : jet.Double) : jet.Boolean
-    public final fun step(/*0*/ step : jet.Double) : jet.DoubleIterator
+    public open override /*2*/ fun iterator() : jet.DoubleIterator
     
     public class object <class-object-for-DoubleRange> {
         private constructor <class-object-for-DoubleRange>()
@@ -374,6 +388,14 @@ public final class DoubleRange : jet.Range<jet.Double> {
     }
 }
 
+public final class DoubleSequence : jet.NumberSequence<jet.Double> {
+    public constructor DoubleSequence(/*0*/ start : jet.Double, /*1*/ end : jet.Double, /*2*/ increment : jet.Double)
+    public open override /*1*/ val end : jet.Double
+    public open override /*1*/ val increment : jet.Double
+    public open override /*1*/ val start : jet.Double
+    public open override /*1*/ fun iterator() : jet.DoubleIterator
+}
+
 public abstract class Enum</*0*/ E : jet.Enum<E>> {
     public constructor Enum</*0*/ E : jet.Enum<E>>(/*0*/ name : jet.String, /*1*/ ordinal : jet.Int)
     public final fun name() : jet.String
@@ -581,13 +603,13 @@ public abstract class FloatIterator : jet.Iterator<jet.Float> {
     public abstract fun nextFloat() : jet.Float
 }
 
-public final class FloatRange : jet.Range<jet.Float> {
-    public constructor FloatRange(/*0*/ start : jet.Float, /*1*/ size : jet.Float)
-    public final val end : jet.Float
-    public final val size : jet.Float
-    public final val start : jet.Float
+public final class FloatRange : jet.Range<jet.Float>, jet.NumberSequence<jet.Float>, jet.FloatIterable {
+    public constructor FloatRange(/*0*/ start : jet.Float, /*1*/ end : jet.Float)
+    public open override /*2*/ val end : jet.Float
+    public open override /*1*/ val increment : jet.Float
+    public open override /*2*/ val start : jet.Float
     public open override /*1*/ fun contains(/*0*/ elem : jet.Float) : jet.Boolean
-    public final fun step(/*0*/ step : jet.Float) : jet.FloatIterator
+    public open override /*2*/ fun iterator() : jet.FloatIterator
     
     public class object <class-object-for-FloatRange> {
         private constructor <class-object-for-FloatRange>()
@@ -595,6 +617,14 @@ public final class FloatRange : jet.Range<jet.Float> {
     }
 }
 
+public final class FloatSequence : jet.NumberSequence<jet.Float> {
+    public constructor FloatSequence(/*0*/ start : jet.Float, /*1*/ end : jet.Float, /*2*/ increment : jet.Float)
+    public open override /*1*/ val end : jet.Float
+    public open override /*1*/ val increment : jet.Float
+    public open override /*1*/ val start : jet.Float
+    public open override /*1*/ fun iterator() : jet.FloatIterator
+}
+
 public abstract class Function0</*0*/ out R> {
     public constructor Function0</*0*/ out R>()
     public abstract fun invoke() : R
@@ -808,14 +838,13 @@ public abstract class IntIterator : jet.Iterator<jet.Int> {
     public abstract fun nextInt() : jet.Int
 }
 
-public final class IntRange : jet.Range<jet.Int>, jet.IntIterable {
-    public constructor IntRange(/*0*/ start : jet.Int, /*1*/ size : jet.Int)
-    public final val end : jet.Int
-    public final val size : jet.Int
-    public final val start : jet.Int
+public final class IntRange : jet.Range<jet.Int>, jet.NumberSequence<jet.Int>, jet.IntIterable {
+    public constructor IntRange(/*0*/ start : jet.Int, /*1*/ end : jet.Int)
+    public open override /*2*/ val end : jet.Int
+    public open override /*1*/ val increment : jet.Int
+    public open override /*2*/ val start : jet.Int
     public open override /*1*/ fun contains(/*0*/ elem : jet.Int) : jet.Boolean
-    public open override /*1*/ fun iterator() : jet.IntIterator
-    public final fun step(/*0*/ step : jet.Int) : jet.IntIterator
+    public open override /*2*/ fun iterator() : jet.IntIterator
     
     public class object <class-object-for-IntRange> {
         private constructor <class-object-for-IntRange>()
@@ -823,6 +852,14 @@ public final class IntRange : jet.Range<jet.Int>, jet.IntIterable {
     }
 }
 
+public final class IntSequence : jet.NumberSequence<jet.Int> {
+    public constructor IntSequence(/*0*/ start : jet.Int, /*1*/ end : jet.Int, /*2*/ increment : jet.Int)
+    public open override /*1*/ val end : jet.Int
+    public open override /*1*/ val increment : jet.Int
+    public open override /*1*/ val start : jet.Int
+    public open override /*1*/ fun iterator() : jet.IntIterator
+}
+
 public trait Iterable</*0*/ out T> {
     public abstract fun iterator() : jet.Iterator<T>
 }
@@ -952,14 +989,13 @@ public abstract class LongIterator : jet.Iterator<jet.Long> {
     public abstract fun nextLong() : jet.Long
 }
 
-public final class LongRange : jet.Range<jet.Long>, jet.LongIterable {
-    public constructor LongRange(/*0*/ start : jet.Long, /*1*/ size : jet.Long)
-    public final val end : jet.Long
-    public final val size : jet.Long
-    public final val start : jet.Long
+public final class LongRange : jet.Range<jet.Long>, jet.NumberSequence<jet.Long>, jet.LongIterable {
+    public constructor LongRange(/*0*/ start : jet.Long, /*1*/ end : jet.Long)
+    public open override /*2*/ val end : jet.Long
+    public open override /*1*/ val increment : jet.Long
+    public open override /*2*/ val start : jet.Long
     public open override /*1*/ fun contains(/*0*/ elem : jet.Long) : jet.Boolean
-    public open override /*1*/ fun iterator() : jet.LongIterator
-    public final fun step(/*0*/ step : jet.Long) : jet.LongIterator
+    public open override /*2*/ fun iterator() : jet.LongIterator
     
     public class object <class-object-for-LongRange> {
         private constructor <class-object-for-LongRange>()
@@ -967,6 +1003,14 @@ public final class LongRange : jet.Range<jet.Long>, jet.LongIterable {
     }
 }
 
+public final class LongSequence : jet.NumberSequence<jet.Long> {
+    public constructor LongSequence(/*0*/ start : jet.Long, /*1*/ end : jet.Long, /*2*/ increment : jet.Long)
+    public open override /*1*/ val end : jet.Long
+    public open override /*1*/ val increment : jet.Long
+    public open override /*1*/ val start : jet.Long
+    public open override /*1*/ fun iterator() : jet.LongIterator
+}
+
 public trait Map</*0*/ K, /*1*/ out V> {
     public abstract fun containsKey(/*0*/ key : jet.Any?) : jet.Boolean
     public abstract fun containsValue(/*0*/ value : jet.Any?) : jet.Boolean
@@ -1111,7 +1155,16 @@ public abstract class Number : jet.Hashable {
     public abstract fun toShort() : jet.Short
 }
 
+public trait NumberSequence</*0*/ N : jet.Number> : jet.Iterable<N> {
+    public abstract val end : N
+    public abstract val increment : jet.Number
+    public abstract val start : N
+    public abstract override /*1*/ /*fake_override*/ fun iterator() : jet.Iterator<N>
+}
+
 public trait Range</*0*/ in T : jet.Comparable<T>> {
+    public abstract val end : T
+    public abstract val start : T
     public abstract fun contains(/*0*/ item : T) : jet.Boolean
 }
 
@@ -1213,14 +1266,13 @@ public abstract class ShortIterator : jet.Iterator<jet.Short> {
     public abstract fun nextShort() : jet.Short
 }
 
-public final class ShortRange : jet.Range<jet.Short>, jet.ShortIterable {
-    public constructor ShortRange(/*0*/ start : jet.Short, /*1*/ size : jet.Int)
-    public final val end : jet.Short
-    public final val size : jet.Int
-    public final val start : jet.Short
+public final class ShortRange : jet.Range<jet.Short>, jet.NumberSequence<jet.Short>, jet.ShortIterable {
+    public constructor ShortRange(/*0*/ start : jet.Short, /*1*/ end : jet.Short)
+    public open override /*2*/ val end : jet.Short
+    public open override /*1*/ val increment : jet.Int
+    public open override /*2*/ val start : jet.Short
     public open override /*1*/ fun contains(/*0*/ elem : jet.Short) : jet.Boolean
-    public open override /*1*/ fun iterator() : jet.ShortIterator
-    public final fun step(/*0*/ step : jet.Int) : jet.ShortIterator
+    public open override /*2*/ fun iterator() : jet.ShortIterator
     
     public class object <class-object-for-ShortRange> {
         private constructor <class-object-for-ShortRange>()
@@ -1228,6 +1280,14 @@ public final class ShortRange : jet.Range<jet.Short>, jet.ShortIterable {
     }
 }
 
+public final class ShortSequence : jet.NumberSequence<jet.Short> {
+    public constructor ShortSequence(/*0*/ start : jet.Short, /*1*/ end : jet.Short, /*2*/ increment : jet.Int)
+    public open override /*1*/ val end : jet.Short
+    public open override /*1*/ val increment : jet.Int
+    public open override /*1*/ val start : jet.Short
+    public open override /*1*/ fun iterator() : jet.ShortIterator
+}
+
 public final class String : jet.Comparable<jet.String>, jet.CharSequence {
     public constructor String()
     public open override /*1*/ val length : jet.Int