NamespaceComparator now serializes kind, if it's not DECLARATION.

Lots of test data changed to include members' kinds.

compiler/testData/builtin-classes.txt

@@ -35,7 +35,7 @@ public abstract trait jet.BooleanIterable : jet.Iterable<jet.Boolean> {
 }
 public abstract class jet.BooleanIterator : jet.Iterator<jet.Boolean> {
     public final /*constructor*/ fun <init>(): jet.BooleanIterator
-    public abstract override /*1*/ fun hasNext(): jet.Boolean
+    public abstract override /*1*/ /*fake_override*/ fun hasNext(): jet.Boolean
     public open override /*1*/ fun next(): jet.Boolean
     public abstract fun nextBoolean(): jet.Boolean
 }
@@ -117,7 +117,7 @@ public abstract trait jet.ByteIterable : jet.Iterable<jet.Byte> {
 }
 public abstract class jet.ByteIterator : jet.Iterator<jet.Byte> {
     public final /*constructor*/ fun <init>(): jet.ByteIterator
-    public abstract override /*1*/ fun hasNext(): jet.Boolean
+    public abstract override /*1*/ /*fake_override*/ fun hasNext(): jet.Boolean
     public open override /*1*/ fun next(): jet.Byte
     public abstract fun nextByte(): jet.Byte
 }
@@ -204,7 +204,7 @@ public abstract trait jet.CharIterable : jet.Iterable<jet.Char> {
 }
 public abstract class jet.CharIterator : jet.Iterator<jet.Char> {
     public final /*constructor*/ fun <init>(): jet.CharIterator
-    public abstract override /*1*/ fun hasNext(): jet.Boolean
+    public abstract override /*1*/ /*fake_override*/ fun hasNext(): jet.Boolean
     public open override /*1*/ fun next(): jet.Char
     public abstract fun nextChar(): jet.Char
 }
@@ -231,8 +231,8 @@ public abstract trait jet.CharSequence : jet.Any {
 public abstract trait jet.Collection</*0*/ out E : jet.Any?> : jet.Iterable<E>, jet.Hashable {
     public abstract fun contains(/*0*/ o: jet.Any?): jet.Boolean
     public abstract fun containsAll(/*0*/ c: jet.Collection<out jet.Any?>): jet.Boolean
-    public abstract override /*1*/ fun equals(/*0*/ other: jet.Any?): jet.Boolean
+    public abstract override /*1*/ /*fake_override*/ fun equals(/*0*/ other: jet.Any?): jet.Boolean
-    public abstract override /*1*/ fun hashCode(): jet.Int
+    public abstract override /*1*/ /*fake_override*/ fun hashCode(): jet.Int
     public abstract fun isEmpty(): jet.Boolean
     public abstract override /*1*/ fun iterator(): jet.Iterator<E>
     public abstract fun size(): jet.Int
@@ -319,7 +319,7 @@ public abstract trait jet.DoubleIterable : jet.Iterable<jet.Double> {
 }
 public abstract class jet.DoubleIterator : jet.Iterator<jet.Double> {
     public final /*constructor*/ fun <init>(): jet.DoubleIterator
-    public abstract override /*1*/ fun hasNext(): jet.Boolean
+    public abstract override /*1*/ /*fake_override*/ fun hasNext(): jet.Boolean
     public open override /*1*/ fun next(): jet.Double
     public abstract fun nextDouble(): jet.Double
 }
@@ -511,7 +511,7 @@ public abstract trait jet.FloatIterable : jet.Iterable<jet.Float> {
 }
 public abstract class jet.FloatIterator : jet.Iterator<jet.Float> {
     public final /*constructor*/ fun <init>(): jet.FloatIterator
-    public abstract override /*1*/ fun hasNext(): jet.Boolean
+    public abstract override /*1*/ /*fake_override*/ fun hasNext(): jet.Boolean
     public open override /*1*/ fun next(): jet.Float
     public abstract fun nextFloat(): jet.Float
 }
@@ -709,7 +709,7 @@ public abstract trait jet.IntIterable : jet.Iterable<jet.Int> {
 }
 public abstract class jet.IntIterator : jet.Iterator<jet.Int> {
     public final /*constructor*/ fun <init>(): jet.IntIterator
-    public abstract override /*1*/ fun hasNext(): jet.Boolean
+    public abstract override /*1*/ /*fake_override*/ fun hasNext(): jet.Boolean
     public open override /*1*/ fun next(): jet.Int
     public abstract fun nextInt(): jet.Int
 }
@@ -738,9 +738,9 @@ public abstract trait jet.Iterator</*0*/ out T : jet.Any?> : jet.Any {
 public abstract trait jet.List</*0*/ out E : jet.Any?> : jet.Collection<E> {
     public abstract override /*1*/ fun contains(/*0*/ o: jet.Any?): jet.Boolean
     public abstract override /*1*/ fun containsAll(/*0*/ c: jet.Collection<out jet.Any?>): jet.Boolean
-    public abstract override /*1*/ fun equals(/*0*/ other: jet.Any?): jet.Boolean
+    public abstract override /*1*/ /*fake_override*/ fun equals(/*0*/ other: jet.Any?): jet.Boolean
     public abstract fun get(/*0*/ index: jet.Int): E
-    public abstract override /*1*/ fun hashCode(): jet.Int
+    public abstract override /*1*/ /*fake_override*/ fun hashCode(): jet.Int
     public abstract fun indexOf(/*0*/ o: jet.Any?): jet.Int
     public abstract override /*1*/ fun isEmpty(): jet.Boolean
     public abstract override /*1*/ fun iterator(): jet.Iterator<E>
@@ -845,7 +845,7 @@ public abstract trait jet.LongIterable : jet.Iterable<jet.Long> {
 }
 public abstract class jet.LongIterator : jet.Iterator<jet.Long> {
     public final /*constructor*/ fun <init>(): jet.LongIterator
-    public abstract override /*1*/ fun hasNext(): jet.Boolean
+    public abstract override /*1*/ /*fake_override*/ fun hasNext(): jet.Boolean
     public open override /*1*/ fun next(): jet.Long
     public abstract fun nextLong(): jet.Long
 }
@@ -871,10 +871,10 @@ public abstract trait jet.Map</*0*/ K : jet.Any?, /*1*/ V : jet.Any?> : jet.Any
     public abstract fun get(/*0*/ key: jet.Any?): V?
     public abstract fun isEmpty(): jet.Boolean
     public abstract trait jet.Map.Entry</*0*/ out K : jet.Any?, /*1*/ out V : jet.Any?> : jet.Hashable {
-        public abstract override /*1*/ fun equals(/*0*/ other: jet.Any?): jet.Boolean
+        public abstract override /*1*/ /*fake_override*/ fun equals(/*0*/ other: jet.Any?): jet.Boolean
         public abstract fun getKey(): K
         public abstract fun getValue(): V
-        public abstract override /*1*/ fun hashCode(): jet.Int
+        public abstract override /*1*/ /*fake_override*/ fun hashCode(): jet.Int
     }
     public abstract fun keySet(): jet.Set<K>
     public abstract fun size(): jet.Int
@@ -884,25 +884,25 @@ public abstract trait jet.MutableCollection</*0*/ E : jet.Any?> : jet.Collection
     public abstract fun add(/*0*/ e: E): jet.Boolean
     public abstract fun addAll(/*0*/ c: jet.Collection<out E>): jet.Boolean
     public abstract fun clear(): jet.Tuple0
-    public abstract override /*1*/ fun contains(/*0*/ o: jet.Any?): jet.Boolean
+    public abstract override /*1*/ /*fake_override*/ fun contains(/*0*/ o: jet.Any?): jet.Boolean
-    public abstract override /*1*/ fun containsAll(/*0*/ c: jet.Collection<out jet.Any?>): jet.Boolean
+    public abstract override /*1*/ /*fake_override*/ fun containsAll(/*0*/ c: jet.Collection<out jet.Any?>): jet.Boolean
-    public abstract override /*1*/ fun equals(/*0*/ other: jet.Any?): jet.Boolean
+    public abstract override /*1*/ /*fake_override*/ fun equals(/*0*/ other: jet.Any?): jet.Boolean
-    public abstract override /*1*/ fun hashCode(): jet.Int
+    public abstract override /*1*/ /*fake_override*/ fun hashCode(): jet.Int
-    public abstract override /*1*/ fun isEmpty(): jet.Boolean
+    public abstract override /*1*/ /*fake_override*/ fun isEmpty(): jet.Boolean
     public abstract override /*2*/ fun iterator(): jet.MutableIterator<E>
     public abstract fun remove(/*0*/ o: jet.Any?): jet.Boolean
     public abstract fun removeAll(/*0*/ c: jet.Collection<out jet.Any?>): jet.Boolean
     public abstract fun retainAll(/*0*/ c: jet.Collection<out jet.Any?>): jet.Boolean
-    public abstract override /*1*/ fun size(): jet.Int
+    public abstract override /*1*/ /*fake_override*/ fun size(): jet.Int
-    public abstract override /*1*/ fun toArray(): jet.Array<jet.Any?>
+    public abstract override /*1*/ /*fake_override*/ fun toArray(): jet.Array<jet.Any?>
-    public abstract override /*1*/ fun </*0*/ T : jet.Any?>toArray(/*0*/ a: jet.Array<out T>): jet.Array<T>
+    public abstract override /*1*/ /*fake_override*/ fun </*0*/ T : jet.Any?>toArray(/*0*/ a: jet.Array<out T>): jet.Array<T>
 }
 public abstract trait jet.MutableIterable</*0*/ out T : jet.Any?> : jet.Iterable<T> {
     public abstract override /*1*/ fun iterator(): jet.MutableIterator<T>
 }
 public abstract trait jet.MutableIterator</*0*/ out T : jet.Any?> : jet.Iterator<T> {
-    public abstract override /*1*/ fun hasNext(): jet.Boolean
+    public abstract override /*1*/ /*fake_override*/ fun hasNext(): jet.Boolean
-    public abstract override /*1*/ fun next(): T
+    public abstract override /*1*/ /*fake_override*/ fun next(): T
     public abstract fun remove(): jet.Tuple0
 }
 public abstract trait jet.MutableList</*0*/ E : jet.Any?> : jet.List<E>, jet.MutableCollection<E> {
@@ -911,83 +911,83 @@ public abstract trait jet.MutableList</*0*/ E : jet.Any?> : jet.List<E>, jet.Mut
     public abstract override /*1*/ fun addAll(/*0*/ c: jet.Collection<out E>): jet.Boolean
     public abstract fun addAll(/*0*/ index: jet.Int, /*1*/ c: jet.Collection<out E>): jet.Boolean
     public abstract override /*1*/ fun clear(): jet.Tuple0
-    public abstract override /*2*/ fun contains(/*0*/ o: jet.Any?): jet.Boolean
+    public abstract override /*2*/ /*fake_override*/ fun contains(/*0*/ o: jet.Any?): jet.Boolean
-    public abstract override /*2*/ fun containsAll(/*0*/ c: jet.Collection<out jet.Any?>): jet.Boolean
+    public abstract override /*2*/ /*fake_override*/ fun containsAll(/*0*/ c: jet.Collection<out jet.Any?>): jet.Boolean
-    public abstract override /*2*/ fun equals(/*0*/ other: jet.Any?): jet.Boolean
+    public abstract override /*2*/ /*fake_override*/ fun equals(/*0*/ other: jet.Any?): jet.Boolean
-    public abstract override /*1*/ fun get(/*0*/ index: jet.Int): E
+    public abstract override /*1*/ /*fake_override*/ fun get(/*0*/ index: jet.Int): E
-    public abstract override /*2*/ fun hashCode(): jet.Int
+    public abstract override /*2*/ /*fake_override*/ fun hashCode(): jet.Int
-    public abstract override /*1*/ fun indexOf(/*0*/ o: jet.Any?): jet.Int
+    public abstract override /*1*/ /*fake_override*/ fun indexOf(/*0*/ o: jet.Any?): jet.Int
-    public abstract override /*2*/ fun isEmpty(): jet.Boolean
+    public abstract override /*2*/ /*fake_override*/ fun isEmpty(): jet.Boolean
-    public abstract override /*2*/ fun iterator(): jet.Iterator<E>
+    public abstract override /*2*/ /*fake_override*/ fun iterator(): jet.Iterator<E>
-    public abstract override /*1*/ fun lastIndexOf(/*0*/ o: jet.Any?): jet.Int
+    public abstract override /*1*/ /*fake_override*/ fun lastIndexOf(/*0*/ o: jet.Any?): jet.Int
-    public abstract override /*1*/ fun listIterator(): jet.ListIterator<E>
+    public abstract override /*1*/ /*fake_override*/ fun listIterator(): jet.ListIterator<E>
-    public abstract override /*1*/ fun listIterator(/*0*/ index: jet.Int): jet.ListIterator<E>
+    public abstract override /*1*/ /*fake_override*/ fun listIterator(/*0*/ index: jet.Int): jet.ListIterator<E>
     public abstract fun remove(/*0*/ index: jet.Int): E
     public abstract override /*1*/ fun remove(/*0*/ o: jet.Any?): jet.Boolean
     public abstract override /*1*/ fun removeAll(/*0*/ c: jet.Collection<out jet.Any?>): jet.Boolean
     public abstract override /*1*/ fun retainAll(/*0*/ c: jet.Collection<out jet.Any?>): jet.Boolean
     public abstract fun set(/*0*/ index: jet.Int, /*1*/ element: E): E
-    public abstract override /*2*/ fun size(): jet.Int
+    public abstract override /*2*/ /*fake_override*/ fun size(): jet.Int
-    public abstract override /*1*/ fun subList(/*0*/ fromIndex: jet.Int, /*1*/ toIndex: jet.Int): jet.List<E>
+    public abstract override /*1*/ /*fake_override*/ fun subList(/*0*/ fromIndex: jet.Int, /*1*/ toIndex: jet.Int): jet.List<E>
-    public abstract override /*2*/ fun toArray(): jet.Array<jet.Any?>
+    public abstract override /*2*/ /*fake_override*/ fun toArray(): jet.Array<jet.Any?>
-    public abstract override /*2*/ fun </*0*/ T : jet.Any?>toArray(/*0*/ a: jet.Array<out T>): jet.Array<T>
+    public abstract override /*2*/ /*fake_override*/ fun </*0*/ T : jet.Any?>toArray(/*0*/ a: jet.Array<out T>): jet.Array<T>
 }
 public abstract trait jet.MutableListIterator</*0*/ T : jet.Any?> : jet.ListIterator<T>, jet.MutableIterator<T> {
     public abstract fun add(/*0*/ e: T): jet.Tuple0
     public abstract override /*2*/ fun hasNext(): jet.Boolean
-    public abstract override /*1*/ fun hasPrevious(): jet.Boolean
+    public abstract override /*1*/ /*fake_override*/ fun hasPrevious(): jet.Boolean
     public abstract override /*2*/ fun next(): T
-    public abstract override /*1*/ fun nextIndex(): jet.Int
+    public abstract override /*1*/ /*fake_override*/ fun nextIndex(): jet.Int
-    public abstract override /*1*/ fun previous(): T
+    public abstract override /*1*/ /*fake_override*/ fun previous(): T
-    public abstract override /*1*/ fun previousIndex(): jet.Int
+    public abstract override /*1*/ /*fake_override*/ fun previousIndex(): jet.Int
     public abstract override /*1*/ fun remove(): jet.Tuple0
     public abstract fun set(/*0*/ e: T): jet.Tuple0
 }
 public abstract trait jet.MutableMap</*0*/ K : jet.Any?, /*1*/ V : jet.Any?> : jet.Map<K, V> {
     public abstract fun clear(): jet.Tuple0
-    public abstract override /*1*/ fun containsKey(/*0*/ key: jet.Any?): jet.Boolean
+    public abstract override /*1*/ /*fake_override*/ fun containsKey(/*0*/ key: jet.Any?): jet.Boolean
-    public abstract override /*1*/ fun containsValue(/*0*/ value: jet.Any?): jet.Boolean
+    public abstract override /*1*/ /*fake_override*/ fun containsValue(/*0*/ value: jet.Any?): jet.Boolean
     public abstract override /*1*/ fun entrySet(): jet.Set<jet.MutableMap.MutableEntry<K, V>>
-    public abstract override /*1*/ fun get(/*0*/ key: jet.Any?): V?
+    public abstract override /*1*/ /*fake_override*/ fun get(/*0*/ key: jet.Any?): V?
-    public abstract override /*1*/ fun isEmpty(): jet.Boolean
+    public abstract override /*1*/ /*fake_override*/ fun isEmpty(): jet.Boolean
     public abstract trait jet.MutableMap.MutableEntry</*0*/ K : jet.Any?, /*1*/ V : jet.Any?> : jet.Map.Entry<K, V>, jet.Hashable {
-        public abstract override /*2*/ fun equals(/*0*/ other: jet.Any?): jet.Boolean
+        public abstract override /*2*/ /*fake_override*/ fun equals(/*0*/ other: jet.Any?): jet.Boolean
-        public abstract override /*1*/ fun getKey(): K
+        public abstract override /*1*/ /*fake_override*/ fun getKey(): K
-        public abstract override /*1*/ fun getValue(): V
+        public abstract override /*1*/ /*fake_override*/ fun getValue(): V
-        public abstract override /*2*/ fun hashCode(): jet.Int
+        public abstract override /*2*/ /*fake_override*/ fun hashCode(): jet.Int
         public abstract fun setValue(/*0*/ value: V): V
     }
-    public abstract override /*1*/ fun keySet(): jet.Set<K>
+    public abstract override /*1*/ /*fake_override*/ fun keySet(): jet.Set<K>
     public abstract fun put(/*0*/ key: K, /*1*/ value: V): V?
     public abstract fun putAll(/*0*/ m: jet.Map<out K, out V>): jet.Tuple0
     public abstract fun remove(/*0*/ key: jet.Any?): V?
-    public abstract override /*1*/ fun size(): jet.Int
+    public abstract override /*1*/ /*fake_override*/ fun size(): jet.Int
-    public abstract override /*1*/ fun values(): jet.Collection<V>
+    public abstract override /*1*/ /*fake_override*/ fun values(): jet.Collection<V>
 }
 public abstract trait jet.MutableSet</*0*/ E : jet.Any?> : jet.Set<E>, jet.MutableCollection<E> {
     public abstract override /*1*/ fun add(/*0*/ e: E): jet.Boolean
     public abstract override /*1*/ fun addAll(/*0*/ c: jet.Collection<out E>): jet.Boolean
     public abstract override /*1*/ fun clear(): jet.Tuple0
-    public abstract override /*2*/ fun contains(/*0*/ o: jet.Any?): jet.Boolean
+    public abstract override /*2*/ /*fake_override*/ fun contains(/*0*/ o: jet.Any?): jet.Boolean
-    public abstract override /*2*/ fun containsAll(/*0*/ c: jet.Collection<out jet.Any?>): jet.Boolean
+    public abstract override /*2*/ /*fake_override*/ fun containsAll(/*0*/ c: jet.Collection<out jet.Any?>): jet.Boolean
-    public abstract override /*2*/ fun equals(/*0*/ other: jet.Any?): jet.Boolean
+    public abstract override /*2*/ /*fake_override*/ fun equals(/*0*/ other: jet.Any?): jet.Boolean
-    public abstract override /*2*/ fun hashCode(): jet.Int
+    public abstract override /*2*/ /*fake_override*/ fun hashCode(): jet.Int
-    public abstract override /*2*/ fun isEmpty(): jet.Boolean
+    public abstract override /*2*/ /*fake_override*/ fun isEmpty(): jet.Boolean
     public abstract override /*2*/ fun iterator(): jet.MutableIterator<E>
     public abstract override /*1*/ fun remove(/*0*/ o: jet.Any?): jet.Boolean
     public abstract override /*1*/ fun removeAll(/*0*/ c: jet.Collection<out jet.Any?>): jet.Boolean
     public abstract override /*1*/ fun retainAll(/*0*/ c: jet.Collection<out jet.Any?>): jet.Boolean
-    public abstract override /*2*/ fun size(): jet.Int
+    public abstract override /*2*/ /*fake_override*/ fun size(): jet.Int
-    public abstract override /*2*/ fun toArray(): jet.Array<jet.Any?>
+    public abstract override /*2*/ /*fake_override*/ fun toArray(): jet.Array<jet.Any?>
-    public abstract override /*2*/ fun </*0*/ T : jet.Any?>toArray(/*0*/ a: jet.Array<out T>): jet.Array<T>
+    public abstract override /*2*/ /*fake_override*/ fun </*0*/ T : jet.Any?>toArray(/*0*/ a: jet.Array<out T>): jet.Array<T>
 }
 public final class jet.Nothing {
     private final /*constructor*/ fun <init>(): jet.Nothing
 }
 public abstract class jet.Number : jet.Hashable {
     public final /*constructor*/ fun <init>(): jet.Number
-    public abstract override /*1*/ fun equals(/*0*/ other: jet.Any?): jet.Boolean
+    public abstract override /*1*/ /*fake_override*/ fun equals(/*0*/ other: jet.Any?): jet.Boolean
-    public abstract override /*1*/ fun hashCode(): jet.Int
+    public abstract override /*1*/ /*fake_override*/ fun hashCode(): jet.Int
     public abstract fun toByte(): jet.Byte
     public abstract fun toChar(): jet.Char
     public abstract fun toDouble(): jet.Double
@@ -1002,8 +1002,8 @@ public abstract trait jet.Range</*0*/ in T : jet.Comparable<T>> : jet.Any {
 public abstract trait jet.Set</*0*/ out E : jet.Any?> : jet.Collection<E> {
     public abstract override /*1*/ fun contains(/*0*/ o: jet.Any?): jet.Boolean
     public abstract override /*1*/ fun containsAll(/*0*/ c: jet.Collection<out jet.Any?>): jet.Boolean
-    public abstract override /*1*/ fun equals(/*0*/ other: jet.Any?): jet.Boolean
+    public abstract override /*1*/ /*fake_override*/ fun equals(/*0*/ other: jet.Any?): jet.Boolean
-    public abstract override /*1*/ fun hashCode(): jet.Int
+    public abstract override /*1*/ /*fake_override*/ fun hashCode(): jet.Int
     public abstract override /*1*/ fun isEmpty(): jet.Boolean
     public abstract override /*1*/ fun iterator(): jet.Iterator<E>
     public abstract override /*1*/ fun size(): jet.Int
@@ -1088,7 +1088,7 @@ public abstract trait jet.ShortIterable : jet.Iterable<jet.Short> {
 }
 public abstract class jet.ShortIterator : jet.Iterator<jet.Short> {
     public final /*constructor*/ fun <init>(): jet.ShortIterator
-    public abstract override /*1*/ fun hasNext(): jet.Boolean
+    public abstract override /*1*/ /*fake_override*/ fun hasNext(): jet.Boolean
     public open override /*1*/ fun next(): jet.Short
     public abstract fun nextShort(): jet.Short
 }

compiler/testData/lazyResolve/namespaceComparator/enum.txt

@@ -2,21 +2,21 @@ namespace test
 
 internal final enum class test.Test : jet.Enum<test.Test> {
     private final /*constructor*/ fun <init>(/*0*/ a: jet.Int): test.Test
-    public final override /*1*/ fun name(): jet.String
+    public final override /*1*/ /*fake_override*/ fun name(): jet.String
-    public final override /*1*/ fun ordinal(): jet.Int
+    public final override /*1*/ /*fake_override*/ fun ordinal(): jet.Int
     internal final class object test.Test.<class-object-for-Test> {
         private final /*constructor*/ fun <init>(): test.Test.<class-object-for-Test>
         internal final val A: test.Test.<class-object-for-Test>.A
         internal final val B: test.Test.<class-object-for-Test>.B
         internal final enum entry test.Test.<class-object-for-Test>.A : test.Test {
             private final /*constructor*/ fun <init>(): test.Test.<class-object-for-Test>.A
-            public final override /*1*/ fun name(): jet.String
+            public final override /*1*/ /*fake_override*/ fun name(): jet.String
-            public final override /*1*/ fun ordinal(): jet.Int
+            public final override /*1*/ /*fake_override*/ fun ordinal(): jet.Int
         }
         internal final enum entry test.Test.<class-object-for-Test>.B : test.Test {
             private final /*constructor*/ fun <init>(): test.Test.<class-object-for-Test>.B
-            public final override /*1*/ fun name(): jet.String
+            public final override /*1*/ /*fake_override*/ fun name(): jet.String
-            public final override /*1*/ fun ordinal(): jet.Int
+            public final override /*1*/ /*fake_override*/ fun ordinal(): jet.Int
         }
         public final fun valueOf(/*0*/ value: jet.String): test.Test
         public final fun values(): jet.Array<test.Test>

compiler/testData/lazyResolve/namespaceComparator/simpleClass.txt

@@ -14,7 +14,7 @@ internal open class test.p.G</*0*/ T : jet.Any?> : jet.Any {
 }
 internal final class test.p.G2</*0*/ E : jet.Any?> : test.p.G<E> {
     public final /*constructor*/ fun </*0*/ E : jet.Any?><init>(): test.p.G2<E>
-    internal final override /*1*/ fun a(): jet.Tuple0
+    internal final override /*1*/ /*fake_override*/ fun a(): jet.Tuple0
     internal open override /*1*/ fun f(): E
     internal final fun g(): E
 }

compiler/testData/loadJava/ClassDoesNotOverrideMethod.txt

@@ -2,26 +2,26 @@ namespace test
 
 public abstract class test.ClassDoesNotOverrideMethod : java.util.Date {
     public final /*constructor*/ fun <init>(): test.ClassDoesNotOverrideMethod
-    public open override /*1*/ fun after(/*0*/ p0: java.util.Date?): jet.Boolean
+    public open override /*1*/ /*fake_override*/ fun after(/*0*/ p0: java.util.Date?): jet.Boolean
-    public open override /*1*/ fun before(/*0*/ p0: java.util.Date?): jet.Boolean
+    public open override /*1*/ /*fake_override*/ fun before(/*0*/ p0: java.util.Date?): jet.Boolean
-    public open override /*1*/ fun compareTo(/*0*/ p0: java.util.Date?): jet.Int
+    public open override /*1*/ /*fake_override*/ fun compareTo(/*0*/ p0: java.util.Date?): jet.Int
-    public open override /*1*/ fun compareTo(/*0*/ p0: jet.Any?): jet.Int
+    public open override /*1*/ /*fake_override*/ fun compareTo(/*0*/ p0: jet.Any?): jet.Int
-    public open override /*1*/ fun getDate(): jet.Int
+    public open override /*1*/ /*fake_override*/ fun getDate(): jet.Int
-    public open override /*1*/ fun getDay(): jet.Int
+    public open override /*1*/ /*fake_override*/ fun getDay(): jet.Int
-    public open override /*1*/ fun getHours(): jet.Int
+    public open override /*1*/ /*fake_override*/ fun getHours(): jet.Int
-    public open override /*1*/ fun getMinutes(): jet.Int
+    public open override /*1*/ /*fake_override*/ fun getMinutes(): jet.Int
-    public open override /*1*/ fun getMonth(): jet.Int
+    public open override /*1*/ /*fake_override*/ fun getMonth(): jet.Int
-    public open override /*1*/ fun getSeconds(): jet.Int
+    public open override /*1*/ /*fake_override*/ fun getSeconds(): jet.Int
-    public open override /*1*/ fun getTime(): jet.Long
+    public open override /*1*/ /*fake_override*/ fun getTime(): jet.Long
-    public open override /*1*/ fun getTimezoneOffset(): jet.Int
+    public open override /*1*/ /*fake_override*/ fun getTimezoneOffset(): jet.Int
-    public open override /*1*/ fun getYear(): jet.Int
+    public open override /*1*/ /*fake_override*/ fun getYear(): jet.Int
-    public open override /*1*/ fun setDate(/*0*/ p0: jet.Int): jet.Tuple0
+    public open override /*1*/ /*fake_override*/ fun setDate(/*0*/ p0: jet.Int): jet.Tuple0
-    public open override /*1*/ fun setHours(/*0*/ p0: jet.Int): jet.Tuple0
+    public open override /*1*/ /*fake_override*/ fun setHours(/*0*/ p0: jet.Int): jet.Tuple0
-    public open override /*1*/ fun setMinutes(/*0*/ p0: jet.Int): jet.Tuple0
+    public open override /*1*/ /*fake_override*/ fun setMinutes(/*0*/ p0: jet.Int): jet.Tuple0
-    public open override /*1*/ fun setMonth(/*0*/ p0: jet.Int): jet.Tuple0
+    public open override /*1*/ /*fake_override*/ fun setMonth(/*0*/ p0: jet.Int): jet.Tuple0
-    public open override /*1*/ fun setSeconds(/*0*/ p0: jet.Int): jet.Tuple0
+    public open override /*1*/ /*fake_override*/ fun setSeconds(/*0*/ p0: jet.Int): jet.Tuple0
-    public open override /*1*/ fun setTime(/*0*/ p0: jet.Long): jet.Tuple0
+    public open override /*1*/ /*fake_override*/ fun setTime(/*0*/ p0: jet.Long): jet.Tuple0
-    public open override /*1*/ fun setYear(/*0*/ p0: jet.Int): jet.Tuple0
+    public open override /*1*/ /*fake_override*/ fun setYear(/*0*/ p0: jet.Int): jet.Tuple0
-    public open override /*1*/ fun toGMTString(): jet.String?
+    public open override /*1*/ /*fake_override*/ fun toGMTString(): jet.String?
-    public open override /*1*/ fun toLocaleString(): jet.String?
+    public open override /*1*/ /*fake_override*/ fun toLocaleString(): jet.String?
 }

compiler/testData/loadJava/ClassWithTypePExtendsIterableP.txt

@@ -2,5 +2,5 @@ namespace test
 
 public abstract class test.ClassWithTypePExtendsIterableP</*0*/ P : jet.Any?> : jet.MutableIterable<P> {
     public final /*constructor*/ fun </*0*/ P : jet.Any?><init>(): test.ClassWithTypePExtendsIterableP<P>
-    public abstract override /*1*/ fun iterator(): jet.MutableIterator<P>
+    public abstract override /*1*/ /*fake_override*/ fun iterator(): jet.MutableIterator<P>
 }

compiler/testData/loadJava/modality/ModalityOfFakeOverrides.txt

@@ -2,29 +2,29 @@ namespace test
 
 public open class test.ModalityOfFakeOverrides : java.util.AbstractList<jet.String> {
     public final /*constructor*/ fun <init>(): test.ModalityOfFakeOverrides
-    public open override /*1*/ fun add(/*0*/ p0: jet.Int, /*1*/ p1: jet.String): jet.Tuple0
+    public open override /*1*/ /*fake_override*/ fun add(/*0*/ p0: jet.Int, /*1*/ p1: jet.String): jet.Tuple0
-    public open override /*1*/ fun add(/*0*/ p0: jet.String): jet.Boolean
+    public open override /*1*/ /*fake_override*/ fun add(/*0*/ p0: jet.String): jet.Boolean
-    public open override /*1*/ fun addAll(/*0*/ p0: jet.Collection<out jet.String>): jet.Boolean
+    public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ p0: jet.Collection<out jet.String>): jet.Boolean
-    public open override /*1*/ fun addAll(/*0*/ p0: jet.Int, /*1*/ p1: jet.Collection<out jet.String>): jet.Boolean
+    public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ p0: jet.Int, /*1*/ p1: jet.Collection<out jet.String>): jet.Boolean
-    public open override /*1*/ fun clear(): jet.Tuple0
+    public open override /*1*/ /*fake_override*/ fun clear(): jet.Tuple0
-    public open override /*1*/ fun contains(/*0*/ p0: jet.Any?): jet.Boolean
+    public open override /*1*/ /*fake_override*/ fun contains(/*0*/ p0: jet.Any?): jet.Boolean
-    public open override /*1*/ fun containsAll(/*0*/ p0: jet.Collection<out jet.Any?>): jet.Boolean
+    public open override /*1*/ /*fake_override*/ fun containsAll(/*0*/ p0: jet.Collection<out jet.Any?>): jet.Boolean
     public open override /*1*/ fun get(/*0*/ p0: jet.Int): jet.String
-    public open override /*1*/ fun indexOf(/*0*/ p0: jet.Any?): jet.Int
+    public open override /*1*/ /*fake_override*/ fun indexOf(/*0*/ p0: jet.Any?): jet.Int
-    public open override /*1*/ fun isEmpty(): jet.Boolean
+    public open override /*1*/ /*fake_override*/ fun isEmpty(): jet.Boolean
-    public open override /*1*/ fun iterator(): jet.MutableIterator<jet.String>
+    public open override /*1*/ /*fake_override*/ fun iterator(): jet.MutableIterator<jet.String>
-    public open override /*1*/ fun lastIndexOf(/*0*/ p0: jet.Any?): jet.Int
+    public open override /*1*/ /*fake_override*/ fun lastIndexOf(/*0*/ p0: jet.Any?): jet.Int
-    public open override /*1*/ fun listIterator(): jet.MutableListIterator<jet.String>
+    public open override /*1*/ /*fake_override*/ fun listIterator(): jet.MutableListIterator<jet.String>
-    public open override /*1*/ fun listIterator(/*0*/ p0: jet.Int): jet.MutableListIterator<jet.String>
+    public open override /*1*/ /*fake_override*/ fun listIterator(/*0*/ p0: jet.Int): jet.MutableListIterator<jet.String>
-    protected final override /*1*/ var modCount: jet.Int
+    protected final override /*1*/ /*fake_override*/ var modCount: jet.Int
-    public open override /*1*/ fun remove(/*0*/ p0: jet.Any?): jet.Boolean
+    public open override /*1*/ /*fake_override*/ fun remove(/*0*/ p0: jet.Any?): jet.Boolean
-    public open override /*1*/ fun remove(/*0*/ p0: jet.Int): jet.String?
+    public open override /*1*/ /*fake_override*/ fun remove(/*0*/ p0: jet.Int): jet.String?
-    public open override /*1*/ fun removeAll(/*0*/ p0: jet.Collection<out jet.Any?>): jet.Boolean
+    public open override /*1*/ /*fake_override*/ fun removeAll(/*0*/ p0: jet.Collection<out jet.Any?>): jet.Boolean
-    protected open override /*1*/ fun removeRange(/*0*/ p0: jet.Int, /*1*/ p1: jet.Int): jet.Tuple0
+    protected open override /*1*/ /*fake_override*/ fun removeRange(/*0*/ p0: jet.Int, /*1*/ p1: jet.Int): jet.Tuple0
-    public open override /*1*/ fun retainAll(/*0*/ p0: jet.Collection<out jet.Any?>): jet.Boolean
+    public open override /*1*/ /*fake_override*/ fun retainAll(/*0*/ p0: jet.Collection<out jet.Any?>): jet.Boolean
-    public open override /*1*/ fun set(/*0*/ p0: jet.Int, /*1*/ p1: jet.String): jet.String
+    public open override /*1*/ /*fake_override*/ fun set(/*0*/ p0: jet.Int, /*1*/ p1: jet.String): jet.String
     public open override /*1*/ fun size(): jet.Int
-    public open override /*1*/ fun subList(/*0*/ p0: jet.Int, /*1*/ p1: jet.Int): jet.MutableList<jet.String>
+    public open override /*1*/ /*fake_override*/ fun subList(/*0*/ p0: jet.Int, /*1*/ p1: jet.Int): jet.MutableList<jet.String>
-    public open override /*1*/ fun toArray(): jet.Array<jet.Any?>
+    public open override /*1*/ /*fake_override*/ fun toArray(): jet.Array<jet.Any?>
-    public open override /*1*/ fun </*0*/ T : jet.Any?>toArray(/*0*/ p0: jet.Array<out T>): jet.Array<T>
+    public open override /*1*/ /*fake_override*/ fun </*0*/ T : jet.Any?>toArray(/*0*/ p0: jet.Array<out T>): jet.Array<T>
 }

compiler/testData/loadJavaCustom/enum/expected.txt

@@ -2,8 +2,8 @@ namespace test
 
 public final enum class test.MyEnum : jet.Enum<test.MyEnum> {
     private final /*constructor*/ fun <init>(): test.MyEnum
-    public final override /*1*/ fun name(): jet.String
+    public final override /*1*/ /*fake_override*/ fun name(): jet.String
-    public final override /*1*/ fun ordinal(): jet.Int
+    public final override /*1*/ /*fake_override*/ fun ordinal(): jet.Int
     public final class object test.MyEnum.<class-object-for-MyEnum> {
         private final /*constructor*/ fun <init>(): test.MyEnum.<class-object-for-MyEnum>
         public final val ANOTHER: test.MyEnum

compiler/testData/loadKotlin/classFun/FunDelegationToTraitImpl.txt

@@ -5,5 +5,5 @@ internal abstract trait test.A : jet.Any {
 }
 internal final class test.B : test.A {
     public final /*constructor*/ fun <init>(): test.B
-    internal open override /*1*/ fun f(): jet.String
+    internal open override /*1*/ /*fake_override*/ fun f(): jet.String
 }

compiler/testData/loadKotlin/classFun/FunInParamSuper.txt

@@ -6,5 +6,5 @@ internal open class test.Base</*0*/ T : jet.Any?> : jet.Any {
 }
 internal final class test.Inh : test.Base<jet.String> {
     public final /*constructor*/ fun <init>(): test.Inh
-    internal final override /*1*/ fun foo(): jet.String
+    internal final override /*1*/ /*fake_override*/ fun foo(): jet.String
 }

compiler/testData/loadKotlin/dataClass/MixedComponents.txt

@@ -2,8 +2,8 @@ namespace test
 
 jet.data() internal final class test.DataClass : jet.Any {
     public final /*constructor*/ fun <init>(/*0*/ x: jet.String, /*1*/ y: jet.Int, /*2*/ z: jet.Double): test.DataClass
-    internal final fun component1(): jet.String
+    internal final /*synthesized*/ fun component1(): jet.String
-    internal final fun component2(): jet.Double
+    internal final /*synthesized*/ fun component2(): jet.Double
     internal final var x: jet.String
     internal final val z: jet.Double
 }

compiler/testData/loadKotlin/dataClass/OneVal.txt

@@ -2,6 +2,6 @@ namespace test
 
 jet.data() internal final class test.DataClass : jet.Any {
     public final /*constructor*/ fun <init>(/*0*/ x: jet.String): test.DataClass
-    internal final fun component1(): jet.String
+    internal final /*synthesized*/ fun component1(): jet.String
     internal final val x: jet.String
 }

compiler/testData/loadKotlin/dataClass/OpenDataClass.txt

@@ -2,6 +2,6 @@ namespace test
 
 jet.data() internal open class test.DataClass : jet.Any {
     public final /*constructor*/ fun <init>(/*0*/ x: jet.String): test.DataClass
-    internal final fun component1(): jet.String
+    internal final /*synthesized*/ fun component1(): jet.String
     internal final val x: jet.String
 }

compiler/testData/loadKotlin/dataClass/OpenPropertyFinalComponent.txt

@@ -2,6 +2,6 @@ namespace test
 
 jet.data() internal open class test.DataClass : jet.Any {
     public final /*constructor*/ fun <init>(/*0*/ x: jet.String): test.DataClass
-    internal final fun component1(): jet.String
+    internal final /*synthesized*/ fun component1(): jet.String
     internal open val x: jet.String
 }

compiler/testData/loadKotlin/dataClass/TwoVals.txt

@@ -2,8 +2,8 @@ namespace test
 
 jet.data() internal final class test.DataClass : jet.Any {
     public final /*constructor*/ fun <init>(/*0*/ x: jet.String, /*1*/ y: jet.Int): test.DataClass
-    internal final fun component1(): jet.String
+    internal final /*synthesized*/ fun component1(): jet.String
-    internal final fun component2(): jet.Int
+    internal final /*synthesized*/ fun component2(): jet.Int
     internal final val x: jet.String
     internal final val y: jet.Int
 }

compiler/testData/loadKotlin/dataClass/TwoVars.txt

@@ -2,8 +2,8 @@ namespace test
 
 jet.data() internal final class test.DataClass : jet.Any {
     public final /*constructor*/ fun <init>(/*0*/ x: jet.String, /*1*/ y: jet.Int): test.DataClass
-    internal final fun component1(): jet.String
+    internal final /*synthesized*/ fun component1(): jet.String
-    internal final fun component2(): jet.Int
+    internal final /*synthesized*/ fun component2(): jet.Int
     internal final var x: jet.String
     internal final var y: jet.Int
 }

compiler/testData/loadKotlin/prop/PropFromSuperclass.txt

@@ -6,5 +6,5 @@ internal open class test.BaseClass : jet.Any {
 }
 internal final class test.Subclass : test.BaseClass {
     public final /*constructor*/ fun <init>(): test.Subclass
-    internal final override /*1*/ val exactly: jet.Int
+    internal final override /*1*/ /*fake_override*/ val exactly: jet.Int
 }

compiler/testData/loadKotlin/prop/VarDelegationToTraitImpl.txt

@@ -5,5 +5,5 @@ internal abstract trait test.A : jet.Any {
 }
 internal final class test.B : test.A {
     public final /*constructor*/ fun <init>(): test.B
-    internal open override /*1*/ var v: jet.String
+    internal open override /*1*/ /*fake_override*/ var v: jet.String
 }

compiler/testData/loadKotlin/visibility/InternalTraitMembersInherited.txt

@@ -7,7 +7,7 @@ internal abstract trait test.A : jet.Any {
 }
 internal final class test.B : test.A {
     public final /*constructor*/ fun <init>(): test.B
-    internal open override /*1*/ fun f(): jet.Int
+    internal open override /*1*/ /*fake_override*/ fun f(): jet.Int
-    public open override /*1*/ var p: jet.Int internal set
+    public open override /*1*/ /*fake_override*/ var p: jet.Int internal set
-    internal open override /*1*/ val v: jet.Int
+    internal open override /*1*/ /*fake_override*/ val v: jet.Int
 }

compiler/testData/loadKotlinCustom/enum/enumVisibilityBinary.txt

@@ -2,8 +2,8 @@ namespace test
 
 internal final enum class test.In : jet.Enum<test.In> {
     private final /*constructor*/ fun <init>(/*0*/ p0: jet.String?, /*1*/ p1: jet.Int): test.In
-    public final override /*1*/ fun name(): jet.String
+    public final override /*1*/ /*fake_override*/ fun name(): jet.String
-    public final override /*1*/ fun ordinal(): jet.Int
+    public final override /*1*/ /*fake_override*/ fun ordinal(): jet.Int
     internal final class object test.In.<class-object-for-In> {
         private final /*constructor*/ fun <init>(): test.In.<class-object-for-In>
         public final val A: test.In
@@ -13,8 +13,8 @@ internal final enum class test.In : jet.Enum<test.In> {
 }
 private final enum class test.Pr : jet.Enum<test.Pr> {
     private final /*constructor*/ fun <init>(/*0*/ p0: jet.String?, /*1*/ p1: jet.Int): test.Pr
-    public final override /*1*/ fun name(): jet.String
+    public final override /*1*/ /*fake_override*/ fun name(): jet.String
-    public final override /*1*/ fun ordinal(): jet.Int
+    public final override /*1*/ /*fake_override*/ fun ordinal(): jet.Int
     private final class object test.Pr.<class-object-for-Pr> {
         private final /*constructor*/ fun <init>(): test.Pr.<class-object-for-Pr>
         public final val A: test.Pr
@@ -24,8 +24,8 @@ private final enum class test.Pr : jet.Enum<test.Pr> {
 }
 public final enum class test.Pu : jet.Enum<test.Pu> {
     private final /*constructor*/ fun <init>(/*0*/ p0: jet.String?, /*1*/ p1: jet.Int): test.Pu
-    public final override /*1*/ fun name(): jet.String
+    public final override /*1*/ /*fake_override*/ fun name(): jet.String
-    public final override /*1*/ fun ordinal(): jet.Int
+    public final override /*1*/ /*fake_override*/ fun ordinal(): jet.Int
     public final class object test.Pu.<class-object-for-Pu> {
         private final /*constructor*/ fun <init>(): test.Pu.<class-object-for-Pu>
         public final val A: test.Pu

compiler/testData/loadKotlinCustom/enum/enumVisibilitySource.txt

@@ -2,15 +2,15 @@ namespace test
 
 internal final enum class test.In : jet.Enum<test.In> {
     private final /*constructor*/ fun <init>(): test.In
-    public final override /*1*/ fun name(): jet.String
+    public final override /*1*/ /*fake_override*/ fun name(): jet.String
-    public final override /*1*/ fun ordinal(): jet.Int
+    public final override /*1*/ /*fake_override*/ fun ordinal(): jet.Int
     internal final class object test.In.<class-object-for-In> {
         private final /*constructor*/ fun <init>(): test.In.<class-object-for-In>
         internal final val A: test.In.<class-object-for-In>.A
         internal final enum entry test.In.<class-object-for-In>.A : test.In {
             private final /*constructor*/ fun <init>(): test.In.<class-object-for-In>.A
-            public final override /*1*/ fun name(): jet.String
+            public final override /*1*/ /*fake_override*/ fun name(): jet.String
-            public final override /*1*/ fun ordinal(): jet.Int
+            public final override /*1*/ /*fake_override*/ fun ordinal(): jet.Int
         }
         public final fun valueOf(/*0*/ value: jet.String): test.In
         public final fun values(): jet.Array<test.In>
@@ -18,15 +18,15 @@ internal final enum class test.In : jet.Enum<test.In> {
 }
 private final enum class test.Pr : jet.Enum<test.Pr> {
     private final /*constructor*/ fun <init>(): test.Pr
-    public final override /*1*/ fun name(): jet.String
+    public final override /*1*/ /*fake_override*/ fun name(): jet.String
-    public final override /*1*/ fun ordinal(): jet.Int
+    public final override /*1*/ /*fake_override*/ fun ordinal(): jet.Int
     private final class object test.Pr.<class-object-for-Pr> {
         private final /*constructor*/ fun <init>(): test.Pr.<class-object-for-Pr>
         internal final val A: test.Pr.<class-object-for-Pr>.A
         internal final enum entry test.Pr.<class-object-for-Pr>.A : test.Pr {
             private final /*constructor*/ fun <init>(): test.Pr.<class-object-for-Pr>.A
-            public final override /*1*/ fun name(): jet.String
+            public final override /*1*/ /*fake_override*/ fun name(): jet.String
-            public final override /*1*/ fun ordinal(): jet.Int
+            public final override /*1*/ /*fake_override*/ fun ordinal(): jet.Int
         }
         public final fun valueOf(/*0*/ value: jet.String): test.Pr
         public final fun values(): jet.Array<test.Pr>
@@ -34,15 +34,15 @@ private final enum class test.Pr : jet.Enum<test.Pr> {
 }
 public final enum class test.Pu : jet.Enum<test.Pu> {
     private final /*constructor*/ fun <init>(): test.Pu
-    public final override /*1*/ fun name(): jet.String
+    public final override /*1*/ /*fake_override*/ fun name(): jet.String
-    public final override /*1*/ fun ordinal(): jet.Int
+    public final override /*1*/ /*fake_override*/ fun ordinal(): jet.Int
     public final class object test.Pu.<class-object-for-Pu> {
         private final /*constructor*/ fun <init>(): test.Pu.<class-object-for-Pu>
         internal final val A: test.Pu.<class-object-for-Pu>.A
         internal final enum entry test.Pu.<class-object-for-Pu>.A : test.Pu {
             private final /*constructor*/ fun <init>(): test.Pu.<class-object-for-Pu>.A
-            public final override /*1*/ fun name(): jet.String
+            public final override /*1*/ /*fake_override*/ fun name(): jet.String
-            public final override /*1*/ fun ordinal(): jet.Int
+            public final override /*1*/ /*fake_override*/ fun ordinal(): jet.Int
         }
         public final fun valueOf(/*0*/ value: jet.String): test.Pu
         public final fun values(): jet.Array<test.Pu>

compiler/testData/loadKotlinCustom/enum/simpleEnumBinary.txt

@@ -2,8 +2,8 @@ namespace test
 
 internal final enum class test.MyEnum : jet.Enum<test.MyEnum> {
     private final /*constructor*/ fun <init>(/*0*/ p0: jet.String?, /*1*/ p1: jet.Int): test.MyEnum
-    public final override /*1*/ fun name(): jet.String
+    public final override /*1*/ /*fake_override*/ fun name(): jet.String
-    public final override /*1*/ fun ordinal(): jet.Int
+    public final override /*1*/ /*fake_override*/ fun ordinal(): jet.Int
     internal final class object test.MyEnum.<class-object-for-MyEnum> {
         private final /*constructor*/ fun <init>(): test.MyEnum.<class-object-for-MyEnum>
         public final val ENTRY: test.MyEnum

compiler/testData/loadKotlinCustom/enum/simpleEnumSource.txt

@@ -2,15 +2,15 @@ namespace test
 
 internal final enum class test.MyEnum : jet.Enum<test.MyEnum> {
     private final /*constructor*/ fun <init>(): test.MyEnum
-    public final override /*1*/ fun name(): jet.String
+    public final override /*1*/ /*fake_override*/ fun name(): jet.String
-    public final override /*1*/ fun ordinal(): jet.Int
+    public final override /*1*/ /*fake_override*/ fun ordinal(): jet.Int
     internal final class object test.MyEnum.<class-object-for-MyEnum> {
         private final /*constructor*/ fun <init>(): test.MyEnum.<class-object-for-MyEnum>
         internal final val ENTRY: test.MyEnum.<class-object-for-MyEnum>.ENTRY
         internal final enum entry test.MyEnum.<class-object-for-MyEnum>.ENTRY : test.MyEnum {
             private final /*constructor*/ fun <init>(): test.MyEnum.<class-object-for-MyEnum>.ENTRY
-            public final override /*1*/ fun name(): jet.String
+            public final override /*1*/ /*fake_override*/ fun name(): jet.String
-            public final override /*1*/ fun ordinal(): jet.Int
+            public final override /*1*/ /*fake_override*/ fun ordinal(): jet.Int
         }
         public final fun valueOf(/*0*/ value: jet.String): test.MyEnum
         public final fun values(): jet.Array<test.MyEnum>

compiler/tests/org/jetbrains/jet/test/util/NamespaceComparator.java

@@ -394,6 +394,12 @@ public class NamespaceComparator {
                 sb.append("override /*").append(fun.getOverriddenDescriptors().size()).append("*/ ");
             }
 
+            if (fun.getKind() != CallableMemberDescriptor.Kind.DECLARATION) {
+                sb.append("/*");
+                new Serializer(sb).serialize(fun.getKind());
+                sb.append("*/ ");
+            }
+
             if (fun instanceof ConstructorDescriptor) {
                 sb.append("/*constructor*/ ");
             }
@@ -464,6 +470,12 @@ public class NamespaceComparator {
                 sb.append("override /*").append(prop.getOverriddenDescriptors().size()).append("*/ ");
             }
 
+            if (prop.getKind() != CallableMemberDescriptor.Kind.DECLARATION) {
+                sb.append("/*");
+                new Serializer(sb).serialize(prop.getKind());
+                sb.append("*/ ");
+            }
+
             if (prop.isVar()) {
                 sb.append("var ");
             }
@@ -531,6 +543,10 @@ public class NamespaceComparator {
             sb.append(visibility);
         }
 
+        public void serialize(CallableMemberDescriptor.Kind kind) {
+            sb.append(kind.name().toLowerCase());
+        }
+
         public void serialize(AnnotationDescriptor annotation) {
             new TypeSerializer(sb).serialize(annotation.getType());
             sb.append("(");