Updated test data. Unit -> jet.Unit.

2013-03-20 20:19:13 +04:00
parent eefdf5790a
commit d194d4d877
99 changed files with 215 additions and 215 deletions
@@ -21,7 +21,7 @@ public final class Array</*0*/ reified T> {
    public final val size : jet.Int
    public final fun get(/*0*/ index : jet.Int) : T
    public final fun iterator() : jet.Iterator<T>
-    public final fun set(/*0*/ index : jet.Int, /*1*/ value : T) : Unit
+    public final fun set(/*0*/ index : jet.Int, /*1*/ value : T) : jet.Unit
 }

 public final class Boolean {
@@ -39,7 +39,7 @@ public final class BooleanArray {
    public final val size : jet.Int
    public final fun get(/*0*/ index : jet.Int) : jet.Boolean
    public final fun iterator() : jet.BooleanIterator
-    public final fun set(/*0*/ index : jet.Int, /*1*/ value : jet.Boolean) : Unit
+    public final fun set(/*0*/ index : jet.Int, /*1*/ value : jet.Boolean) : jet.Unit
 }

 public abstract class BooleanIterator : jet.Iterator<jet.Boolean> {
@@ -121,7 +121,7 @@ public final class ByteArray {
    public final val size : jet.Int
    public final fun get(/*0*/ index : jet.Int) : jet.Byte
    public final fun iterator() : jet.ByteIterator
-    public final fun set(/*0*/ index : jet.Int, /*1*/ value : jet.Byte) : Unit
+    public final fun set(/*0*/ index : jet.Int, /*1*/ value : jet.Byte) : jet.Unit
 }

 public abstract class ByteIterator : jet.Iterator<jet.Byte> {
@@ -215,7 +215,7 @@ public final class CharArray {
    public final val size : jet.Int
    public final fun get(/*0*/ index : jet.Int) : jet.Char
    public final fun iterator() : jet.CharIterator
-    public final fun set(/*0*/ index : jet.Int, /*1*/ value : jet.Char) : Unit
+    public final fun set(/*0*/ index : jet.Int, /*1*/ value : jet.Char) : jet.Unit
 }

 public abstract class CharIterator : jet.Iterator<jet.Char> {
@@ -340,7 +340,7 @@ public final class DoubleArray {
    public final val size : jet.Int
    public final fun get(/*0*/ index : jet.Int) : jet.Double
    public final fun iterator() : jet.DoubleIterator
-    public final fun set(/*0*/ index : jet.Int, /*1*/ value : jet.Double) : Unit
+    public final fun set(/*0*/ index : jet.Int, /*1*/ value : jet.Double) : jet.Unit
 }

 public abstract class DoubleIterator : jet.Iterator<jet.Double> {
@@ -565,7 +565,7 @@ public final class FloatArray {
    public final val size : jet.Int
    public final fun get(/*0*/ index : jet.Int) : jet.Float
    public final fun iterator() : jet.FloatIterator
-    public final fun set(/*0*/ index : jet.Int, /*1*/ value : jet.Float) : Unit
+    public final fun set(/*0*/ index : jet.Int, /*1*/ value : jet.Float) : jet.Unit
 }

 public abstract class FloatIterator : jet.Iterator<jet.Float> {
@@ -796,7 +796,7 @@ public final class IntArray {
    public final val size : jet.Int
    public final fun get(/*0*/ index : jet.Int) : jet.Int
    public final fun iterator() : jet.IntIterator
-    public final fun set(/*0*/ index : jet.Int, /*1*/ value : jet.Int) : Unit
+    public final fun set(/*0*/ index : jet.Int, /*1*/ value : jet.Int) : jet.Unit
 }

 public abstract class IntIterator : jet.Iterator<jet.Int> {
@@ -943,7 +943,7 @@ public final class LongArray {
    public final val size : jet.Int
    public final fun get(/*0*/ index : jet.Int) : jet.Long
    public final fun iterator() : jet.LongIterator
-    public final fun set(/*0*/ index : jet.Int, /*1*/ value : jet.Long) : Unit
+    public final fun set(/*0*/ index : jet.Int, /*1*/ value : jet.Long) : jet.Unit
 }

 public abstract class LongIterator : jet.Iterator<jet.Long> {
@@ -996,7 +996,7 @@ public trait Map</*0*/ K, /*1*/ out V> {
 public trait MutableCollection</*0*/ E> : jet.Collection<E>, jet.MutableIterable<E> {
    public abstract fun add(/*0*/ e : E) : jet.Boolean
    public abstract fun addAll(/*0*/ c : jet.Collection<E>) : jet.Boolean
-    public abstract fun clear() : Unit
+    public abstract fun clear() : jet.Unit
    public abstract override /*1*/ /*fake_override*/ fun contains(/*0*/ o : jet.Any?) : jet.Boolean
    public abstract override /*1*/ /*fake_override*/ fun containsAll(/*0*/ c : jet.Collection<jet.Any?>) : jet.Boolean
    public abstract override /*1*/ /*fake_override*/ fun equals(/*0*/ other : jet.Any?) : jet.Boolean
@@ -1018,15 +1018,15 @@ public trait MutableIterable</*0*/ out T> : jet.Iterable<T> {
 public trait MutableIterator</*0*/ out T> : jet.Iterator<T> {
    public abstract override /*1*/ /*fake_override*/ fun hasNext() : jet.Boolean
    public abstract override /*1*/ /*fake_override*/ fun next() : T
-    public abstract fun remove() : Unit
+    public abstract fun remove() : jet.Unit
 }

 public trait MutableList</*0*/ E> : jet.List<E>, jet.MutableCollection<E> {
    public abstract override /*1*/ fun add(/*0*/ e : E) : jet.Boolean
-    public abstract fun add(/*0*/ index : jet.Int, /*1*/ element : E) : Unit
+    public abstract fun add(/*0*/ index : jet.Int, /*1*/ element : E) : jet.Unit
    public abstract override /*1*/ fun addAll(/*0*/ c : jet.Collection<E>) : jet.Boolean
    public abstract fun addAll(/*0*/ index : jet.Int, /*1*/ c : jet.Collection<E>) : jet.Boolean
-    public abstract override /*1*/ fun clear() : Unit
+    public abstract override /*1*/ fun clear() : jet.Unit
    public abstract override /*2*/ /*fake_override*/ fun contains(/*0*/ o : jet.Any?) : jet.Boolean
    public abstract override /*2*/ /*fake_override*/ fun containsAll(/*0*/ c : jet.Collection<jet.Any?>) : jet.Boolean
    public abstract override /*2*/ /*fake_override*/ fun equals(/*0*/ other : jet.Any?) : jet.Boolean
@@ -1050,19 +1050,19 @@ public trait MutableList</*0*/ E> : jet.List<E>, jet.MutableCollection<E> {
 }

 public trait MutableListIterator</*0*/ T> : jet.ListIterator<T>, jet.MutableIterator<T> {
-    public abstract fun add(/*0*/ e : T) : Unit
+    public abstract fun add(/*0*/ e : T) : jet.Unit
    public abstract override /*2*/ fun hasNext() : jet.Boolean
    public abstract override /*1*/ /*fake_override*/ fun hasPrevious() : jet.Boolean
    public abstract override /*2*/ fun next() : T
    public abstract override /*1*/ /*fake_override*/ fun nextIndex() : jet.Int
    public abstract override /*1*/ /*fake_override*/ fun previous() : T
    public abstract override /*1*/ /*fake_override*/ fun previousIndex() : jet.Int
-    public abstract override /*1*/ fun remove() : Unit
-    public abstract fun set(/*0*/ e : T) : Unit
+    public abstract override /*1*/ fun remove() : jet.Unit
+    public abstract fun set(/*0*/ e : T) : jet.Unit
 }

 public trait MutableMap</*0*/ K, /*1*/ V> : jet.Map<K, V> {
-    public abstract fun clear() : Unit
+    public abstract fun clear() : jet.Unit
    public abstract override /*1*/ /*fake_override*/ fun containsKey(/*0*/ key : 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.MutableSet<jet.MutableMap.MutableEntry<K, V>>
@@ -1070,7 +1070,7 @@ public trait MutableMap</*0*/ K, /*1*/ V> : jet.Map<K, V> {
    public abstract override /*1*/ /*fake_override*/ fun isEmpty() : jet.Boolean
    public abstract override /*1*/ fun keySet() : jet.MutableSet<K>
    public abstract fun put(/*0*/ key : K, /*1*/ value : V) : V?
-    public abstract fun putAll(/*0*/ m : jet.Map<out K, V>) : Unit
+    public abstract fun putAll(/*0*/ m : jet.Map<out K, V>) : jet.Unit
    public abstract fun remove(/*0*/ key : jet.Any?) : V?
    public abstract override /*1*/ /*fake_override*/ fun size() : jet.Int
    public abstract override /*1*/ fun values() : jet.MutableCollection<V>
@@ -1087,7 +1087,7 @@ public trait MutableMap</*0*/ K, /*1*/ V> : jet.Map<K, V> {
 public trait MutableSet</*0*/ E> : 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<E>) : jet.Boolean
-    public abstract override /*1*/ fun clear() : Unit
+    public abstract override /*1*/ fun clear() : jet.Unit
    public abstract override /*2*/ /*fake_override*/ fun contains(/*0*/ o : jet.Any?) : jet.Boolean
    public abstract override /*2*/ /*fake_override*/ fun containsAll(/*0*/ c : jet.Collection<jet.Any?>) : jet.Boolean
    public abstract override /*2*/ /*fake_override*/ fun equals(/*0*/ other : jet.Any?) : jet.Boolean
@@ -1216,7 +1216,7 @@ public final class ShortArray {
    public final val size : jet.Int
    public final fun get(/*0*/ index : jet.Int) : jet.Short
    public final fun iterator() : jet.ShortIterator
-    public final fun set(/*0*/ index : jet.Int, /*1*/ value : jet.Short) : Unit
+    public final fun set(/*0*/ index : jet.Int, /*1*/ value : jet.Short) : jet.Unit
 }

 public abstract class ShortIterator : jet.Iterator<jet.Short> {
@@ -1262,7 +1262,7 @@ public open class Throwable {
    public constructor Throwable(/*0*/ message : jet.String? = ..., /*1*/ cause : jet.Throwable? = ...)
    public final fun getCause() : jet.Throwable?
    public final fun getMessage() : jet.String?
-    public final fun printStackTrace() : Unit
+    public final fun printStackTrace() : jet.Unit
 }

 public final class Unit {
@@ -1270,7 +1270,7 @@ public final class Unit {
    
    public class object <class-object-for-Unit> {
        private constructor <class-object-for-Unit>()
-        public final val VALUE : Unit
+        public final val VALUE : jet.Unit
    }
 }

@@ -5,7 +5,7 @@ internal final class B {
    
    internal final class B {
        /*primary*/ public constructor B()
-        internal final fun foo(/*0*/ b : test.B.B.C) : Unit
+        internal final fun foo(/*0*/ b : test.B.B.C) : jet.Unit
        
        internal final class C {
            /*primary*/ public constructor C()
@@ -2,10 +2,10 @@ package test

 internal open class A {
    /*primary*/ public constructor A()
-    internal open fun foo(/*0*/ a : [ERROR : E]) : Unit
+    internal open fun foo(/*0*/ a : [ERROR : E]) : jet.Unit
 }

 internal final class B : test.A {
    /*primary*/ public constructor B()
-    internal open override /*1*/ fun foo(/*0*/ a : [ERROR : E]) : Unit
+    internal open override /*1*/ fun foo(/*0*/ a : [ERROR : E]) : jet.Unit
 }
@@ -5,23 +5,23 @@ internal final class A {
 }

 package p {
-    internal fun foo() : Unit
-    internal fun foo(/*0*/ a : test.p.C) : Unit
+    internal fun foo() : jet.Unit
+    internal fun foo(/*0*/ a : test.p.C) : jet.Unit
    
    internal final class C {
        /*primary*/ public constructor C()
-        internal final fun f() : Unit
+        internal final fun f() : jet.Unit
    }
    
    internal open class G</*0*/ T> {
        /*primary*/ public constructor G</*0*/ T>()
-        internal final fun a() : Unit
+        internal final fun a() : jet.Unit
        internal open fun f() : T
    }
    
    internal final class G2</*0*/ E> : test.p.G<E> {
        /*primary*/ public constructor G2</*0*/ E>()
-        internal final override /*1*/ /*fake_override*/ fun a() : Unit
+        internal final override /*1*/ /*fake_override*/ fun a() : jet.Unit
        internal open override /*1*/ fun f() : E
        internal final fun g() : E
    }
@@ -2,5 +2,5 @@ package test

 public open class ProtectedPackageFun : java.lang.Object {
    public constructor ProtectedPackageFun()
-    protected/*protected and package*/ open fun foo() : Unit
+    protected/*protected and package*/ open fun foo() : jet.Unit
 }
@@ -5,10 +5,10 @@ public open class RawSuperType : java.lang.Object {
    
    public open inner class Derived : test.RawSuperType.Super<jet.Any?> {
        public constructor Derived()
-        public open override /*1*/ fun foo(/*0*/ p0 : jet.Any?) : Unit
+        public open override /*1*/ fun foo(/*0*/ p0 : jet.Any?) : jet.Unit
    }
    
    public trait Super</*0*/ T> : java.lang.Object {
-        public abstract fun foo(/*0*/ p0 : T?) : Unit
+        public abstract fun foo(/*0*/ p0 : T?) : jet.Unit
    }
 }
@@ -3,15 +3,15 @@ package test
 public trait TwoSuperclassesVarargAndNot : java.lang.Object {
    
    public trait Sub : test.TwoSuperclassesVarargAndNot.Super1, test.TwoSuperclassesVarargAndNot.Super2 {
-        public abstract override /*1*/ /*fake_override*/ fun foo(/*0*/ vararg p0 : jet.String? /*jet.Array<jet.String?>*/) : Unit
-        public abstract override /*1*/ fun foo(/*0*/ p0 : jet.Array<out jet.String?>?) : Unit
+        public abstract override /*1*/ /*fake_override*/ fun foo(/*0*/ vararg p0 : jet.String? /*jet.Array<jet.String?>*/) : jet.Unit
+        public abstract override /*1*/ fun foo(/*0*/ p0 : jet.Array<out jet.String?>?) : jet.Unit
    }
    
    public trait Super1 : java.lang.Object {
-        public abstract fun foo(/*0*/ vararg p0 : jet.String? /*jet.Array<jet.String?>*/) : Unit
+        public abstract fun foo(/*0*/ vararg p0 : jet.String? /*jet.Array<jet.String?>*/) : jet.Unit
    }
    
    public trait Super2 : java.lang.Object {
-        public abstract fun foo(/*0*/ p0 : jet.Array<out jet.String?>?) : Unit
+        public abstract fun foo(/*0*/ p0 : jet.Array<out jet.String?>?) : jet.Unit
    }
 }
@@ -5,15 +5,15 @@ public open class DeeplyInnerClass : java.lang.Object {
    
    public/*package*/ open inner class A : java.lang.Object {
        public/*package*/ constructor A()
-        public/*package*/ open fun a() : Unit
+        public/*package*/ open fun a() : jet.Unit
        
        public/*package*/ open inner class B : java.lang.Object {
            public/*package*/ constructor B()
-            public/*package*/ open fun b() : Unit
+            public/*package*/ open fun b() : jet.Unit
            
            public/*package*/ open inner class C : java.lang.Object {
                public/*package*/ constructor C()
-                public/*package*/ open fun c() : Unit
+                public/*package*/ open fun c() : jet.Unit
            }
        }
    }
@@ -16,13 +16,13 @@ public final enum class Enum : jet.Enum<test.Enum> {
    
    public open inner class Inner : java.lang.Object {
        public constructor Inner()
-        public/*package*/ open fun bar() : Unit
-        public/*package*/ open fun valueOf(/*0*/ p0 : jet.String?) : Unit
+        public/*package*/ open fun bar() : jet.Unit
+        public/*package*/ open fun valueOf(/*0*/ p0 : jet.String?) : jet.Unit
    }
    
    public open class Nested : java.lang.Object {
        public constructor Nested()
-        public/*package*/ open fun foo() : Unit
-        public/*package*/ open fun values() : Unit
+        public/*package*/ open fun foo() : jet.Unit
+        public/*package*/ open fun values() : jet.Unit
    }
 }
@@ -5,11 +5,11 @@ public open class InnerClass : java.lang.Object {
    
    public open inner class Inner : java.lang.Object {
        public constructor Inner()
-        public open fun foo() : Unit
+        public open fun foo() : jet.Unit
    }
    
    public open class Nested : java.lang.Object {
        public constructor Nested()
-        public open fun bar() : Unit
+        public open fun bar() : jet.Unit
    }
 }
@@ -2,9 +2,9 @@ package test

 public open class Simple : java.lang.Object {
    public constructor Simple()
-    public open fun foo() : Unit
+    public open fun foo() : jet.Unit
 }

 package Simple {
-    public open fun bar() : Unit
+    public open fun bar() : jet.Unit
 }
@@ -16,7 +16,7 @@ public final enum class StaticMembersInEnum : jet.Enum<test.StaticMembersInEnum>
 package StaticMembersInEnum {
    public val CONSTANT : test.StaticMembersInEnum
    public var STATIC_FIELD : jet.Int
-    public open fun foo() : Unit
-    public open fun valueOf(/*0*/ p0 : jet.Int) : Unit
-    public open fun values(/*0*/ p0 : jet.Int) : Unit
+    public open fun foo() : jet.Unit
+    public open fun valueOf(/*0*/ p0 : jet.Int) : jet.Unit
+    public open fun values(/*0*/ p0 : jet.Int) : jet.Unit
 }
@@ -14,13 +14,13 @@ public abstract class ClassDoesNotOverrideMethod : java.util.Date {
    public open override /*1*/ /*fake_override*/ fun getTime() : jet.Long
    jet.deprecated(value = "Deprecated in Java": jet.String) public open override /*1*/ /*fake_override*/ fun getTimezoneOffset() : jet.Int
    jet.deprecated(value = "Deprecated in Java": jet.String) public open override /*1*/ /*fake_override*/ fun getYear() : jet.Int
-    jet.deprecated(value = "Deprecated in Java": jet.String) public open override /*1*/ /*fake_override*/ fun setDate(/*0*/ p0 : jet.Int) : Unit
-    jet.deprecated(value = "Deprecated in Java": jet.String) public open override /*1*/ /*fake_override*/ fun setHours(/*0*/ p0 : jet.Int) : Unit
-    jet.deprecated(value = "Deprecated in Java": jet.String) public open override /*1*/ /*fake_override*/ fun setMinutes(/*0*/ p0 : jet.Int) : Unit
-    jet.deprecated(value = "Deprecated in Java": jet.String) public open override /*1*/ /*fake_override*/ fun setMonth(/*0*/ p0 : jet.Int) : Unit
-    jet.deprecated(value = "Deprecated in Java": jet.String) public open override /*1*/ /*fake_override*/ fun setSeconds(/*0*/ p0 : jet.Int) : Unit
-    public open override /*1*/ /*fake_override*/ fun setTime(/*0*/ p0 : jet.Long) : Unit
-    jet.deprecated(value = "Deprecated in Java": jet.String) public open override /*1*/ /*fake_override*/ fun setYear(/*0*/ p0 : jet.Int) : Unit
+    jet.deprecated(value = "Deprecated in Java": jet.String) public open override /*1*/ /*fake_override*/ fun setDate(/*0*/ p0 : jet.Int) : jet.Unit
+    jet.deprecated(value = "Deprecated in Java": jet.String) public open override /*1*/ /*fake_override*/ fun setHours(/*0*/ p0 : jet.Int) : jet.Unit
+    jet.deprecated(value = "Deprecated in Java": jet.String) public open override /*1*/ /*fake_override*/ fun setMinutes(/*0*/ p0 : jet.Int) : jet.Unit
+    jet.deprecated(value = "Deprecated in Java": jet.String) public open override /*1*/ /*fake_override*/ fun setMonth(/*0*/ p0 : jet.Int) : jet.Unit
+    jet.deprecated(value = "Deprecated in Java": jet.String) public open override /*1*/ /*fake_override*/ fun setSeconds(/*0*/ p0 : jet.Int) : jet.Unit
+    public open override /*1*/ /*fake_override*/ fun setTime(/*0*/ p0 : jet.Long) : jet.Unit
+    jet.deprecated(value = "Deprecated in Java": jet.String) public open override /*1*/ /*fake_override*/ fun setYear(/*0*/ p0 : jet.Int) : jet.Unit
    jet.deprecated(value = "Deprecated in Java": jet.String) public open override /*1*/ /*fake_override*/ fun toGMTString() : jet.String
    jet.deprecated(value = "Deprecated in Java": jet.String) public open override /*1*/ /*fake_override*/ fun toLocaleString() : jet.String
 }
@@ -5,6 +5,6 @@ public final class MethodReferencesOuterClassTP</*0*/ P> : java.lang.Object {
    
    public final inner class Inner : java.lang.Object {
        public constructor Inner()
-        public final fun </*0*/ Q : P> f() : Unit
+        public final fun </*0*/ Q : P> f() : jet.Unit
    }
 }
@@ -2,5 +2,5 @@ package test

 public open class MethodTypePOneUpperBound : java.lang.Object {
    public constructor MethodTypePOneUpperBound()
-    public open fun </*0*/ T : java.lang.Cloneable?> bar() : Unit
+    public open fun </*0*/ T : java.lang.Cloneable?> bar() : jet.Unit
 }
@@ -2,5 +2,5 @@ package test

 public open class MethodTypePTwoUpperBounds : java.lang.Object {
    public constructor MethodTypePTwoUpperBounds()
-    public open fun </*0*/ T> foo() : Unit where T : java.lang.Cloneable?, T : java.lang.Runnable?
+    public open fun </*0*/ T> foo() : jet.Unit where T : java.lang.Cloneable?, T : java.lang.Runnable?
 }
@@ -2,5 +2,5 @@ package test

 public final class MethodWithTypeP : java.lang.Object {
    public constructor MethodWithTypeP()
-    public final fun </*0*/ P> f() : Unit
+    public final fun </*0*/ P> f() : jet.Unit
 }
@@ -2,5 +2,5 @@ package test

 public final class MethodWithTypePP : java.lang.Object {
    public constructor MethodWithTypePP()
-    public final fun </*0*/ P, /*1*/ Q : P> f() : Unit
+    public final fun </*0*/ P, /*1*/ Q : P> f() : jet.Unit
 }
@@ -2,5 +2,5 @@ package test

 public open class MethodWithTypePRefClassP</*0*/ P> : java.lang.Object {
    public constructor MethodWithTypePRefClassP</*0*/ P>()
-    public final fun </*0*/ Q : P> f() : Unit
+    public final fun </*0*/ Q : P> f() : jet.Unit
 }
@@ -2,5 +2,5 @@ package test

 public final class MethosWithPRefTP : java.lang.Object {
    public constructor MethosWithPRefTP()
-    public final fun </*0*/ P> f(/*0*/ p0 : P?) : Unit
+    public final fun </*0*/ P> f(/*0*/ p0 : P?) : jet.Unit
 }
@@ -1,6 +1,6 @@
 package test

 public trait RemoveRedundantProjectionKind : java.lang.Object {
-    public abstract fun f(/*0*/ p0 : jet.Collection<jet.CharSequence?>?) : Unit
-    public abstract fun f(/*0*/ p0 : jet.Comparable<jet.CharSequence?>?) : Unit
+    public abstract fun f(/*0*/ p0 : jet.Collection<jet.CharSequence?>?) : jet.Unit
+    public abstract fun f(/*0*/ p0 : jet.Comparable<jet.CharSequence?>?) : jet.Unit
 }
@@ -2,5 +2,5 @@ package test

 public open class AnnotatedMethod : java.lang.Object {
    public constructor AnnotatedMethod()
-    jet.deprecated(value = "Deprecated in Java": jet.String) public open fun f() : Unit
+    jet.deprecated(value = "Deprecated in Java": jet.String) public open fun f() : jet.Unit
 }
@@ -3,5 +3,5 @@ package test
 public open class DifferentGetterAndSetter : java.lang.Object {
    public constructor DifferentGetterAndSetter()
    public open fun getSomething() : jet.Int
-    public open fun setSomething(/*0*/ p0 : jet.String?) : Unit
+    public open fun setSomething(/*0*/ p0 : jet.String?) : jet.Unit
 }
@@ -3,5 +3,5 @@ package test
 public open class JavaBeanVar : java.lang.Object {
    public constructor JavaBeanVar()
    public open fun getColor() : jet.String?
-    public open fun setColor(/*0*/ p0 : jet.String?) : Unit
+    public open fun setColor(/*0*/ p0 : jet.String?) : jet.Unit
 }
@@ -3,5 +3,5 @@ package test
 public open class JavaBeanVarOfGenericType</*0*/ P> : java.lang.Object {
    public constructor JavaBeanVarOfGenericType</*0*/ P>()
    public open fun getCharacters() : java.util.ArrayList<P>?
-    public open fun setCharacters(/*0*/ p0 : java.util.ArrayList<P>?) : Unit
+    public open fun setCharacters(/*0*/ p0 : java.util.ArrayList<P>?) : jet.Unit
 }
@@ -2,6 +2,6 @@ package test

 public open class TwoSetters : java.lang.Object {
    public constructor TwoSetters()
-    public open fun setSize(/*0*/ p0 : jet.Int) : Unit
-    public open fun setSize(/*0*/ p0 : jet.String?) : Unit
+    public open fun setSize(/*0*/ p0 : jet.Int) : jet.Unit
+    public open fun setSize(/*0*/ p0 : jet.String?) : jet.Unit
 }
@@ -2,5 +2,5 @@ package test

 public open class MethodWithMappedClasses : java.lang.Object {
    public constructor MethodWithMappedClasses()
-    public open fun </*0*/ T> copy(/*0*/ p0 : jet.MutableList<in T>, /*1*/ p1 : jet.List<T>) : Unit
+    public open fun </*0*/ T> copy(/*0*/ p0 : jet.MutableList<in T>, /*1*/ p1 : jet.List<T>) : jet.Unit
 }
@@ -2,5 +2,5 @@ package test

 public open class MethodWithTypeParameters : java.lang.Object {
    public constructor MethodWithTypeParameters()
-    public open fun </*0*/ A, /*1*/ B> foo(/*0*/ p0 : A, /*1*/ p1 : jet.List<B>, /*2*/ p2 : jet.MutableList<in jet.String?>) : Unit where B : java.lang.Runnable, B : jet.List<java.lang.Cloneable>
+    public open fun </*0*/ A, /*1*/ B> foo(/*0*/ p0 : A, /*1*/ p1 : jet.List<B>, /*2*/ p2 : jet.MutableList<in jet.String?>) : jet.Unit where B : java.lang.Runnable, B : jet.List<java.lang.Cloneable>
 }
@@ -2,5 +2,5 @@ package test

 public open class MethodWithVararg : java.lang.Object {
    public constructor MethodWithVararg()
-    public open fun foo(/*0*/ vararg p0 : jet.String /*jet.Array<jet.String>*/) : Unit
+    public open fun foo(/*0*/ vararg p0 : jet.String /*jet.Array<jet.String>*/) : jet.Unit
 }
@@ -2,5 +2,5 @@ package test

 public open class ConflictingProjectionKind : java.lang.Object {
    public constructor ConflictingProjectionKind()
-    public open fun foo(/*0*/ p0 : jet.List<jet.Number>?) : Unit
+    public open fun foo(/*0*/ p0 : jet.List<jet.Number>?) : jet.Unit
 }
@@ -2,5 +2,5 @@ package test

 public open class NotVarargReplacedWithVararg : java.lang.Object {
    public constructor NotVarargReplacedWithVararg()
-    public open fun foo(/*0*/ p0 : jet.String?) : Unit
+    public open fun foo(/*0*/ p0 : jet.String?) : jet.Unit
 }
@@ -2,5 +2,5 @@ package test

 public open class RedundantProjectionKind : java.lang.Object {
    public constructor RedundantProjectionKind()
-    public open fun foo(/*0*/ p0 : jet.List<jet.Number>) : Unit
+    public open fun foo(/*0*/ p0 : jet.List<jet.Number>) : jet.Unit
 }
@@ -2,5 +2,5 @@ package test

 public open class VarargReplacedWithNotVararg : java.lang.Object {
    public constructor VarargReplacedWithNotVararg()
-    public open fun foo(/*0*/ vararg p0 : jet.String? /*jet.Array<jet.String?>*/) : Unit
+    public open fun foo(/*0*/ vararg p0 : jet.String? /*jet.Array<jet.String?>*/) : jet.Unit
 }
@@ -2,5 +2,5 @@ package test

 public open class WrongTypeParameterBoundStructure1 : java.lang.Object {
    public constructor WrongTypeParameterBoundStructure1()
-    public open fun </*0*/ A, /*1*/ B> foo(/*0*/ p0 : A?, /*1*/ p1 : jet.List<B>?) : Unit where B : java.lang.Runnable?, B : jet.List<java.lang.Cloneable>?
+    public open fun </*0*/ A, /*1*/ B> foo(/*0*/ p0 : A?, /*1*/ p1 : jet.List<B>?) : jet.Unit where B : java.lang.Runnable?, B : jet.List<java.lang.Cloneable>?
 }
@@ -2,5 +2,5 @@ package test

 public open class WrongTypeParameterBoundStructure2 : java.lang.Object {
    public constructor WrongTypeParameterBoundStructure2()
-    public open fun </*0*/ A, /*1*/ B> foo(/*0*/ p0 : A?, /*1*/ p1 : jet.List<B>?) : Unit where B : java.lang.Runnable?, B : jet.List<java.lang.Cloneable>?
+    public open fun </*0*/ A, /*1*/ B> foo(/*0*/ p0 : A?, /*1*/ p1 : jet.List<B>?) : jet.Unit where B : java.lang.Runnable?, B : jet.List<java.lang.Cloneable>?
 }
@@ -2,5 +2,5 @@ package test

 public open class WrongTypeParametersCount : java.lang.Object {
    public constructor WrongTypeParametersCount()
-    public open fun </*0*/ A, /*1*/ B> foo(/*0*/ p0 : A?, /*1*/ p1 : jet.List<B>?) : Unit
+    public open fun </*0*/ A, /*1*/ B> foo(/*0*/ p0 : A?, /*1*/ p1 : jet.List<B>?) : jet.Unit
 }
@@ -4,19 +4,19 @@ public trait PropagateTypeArgumentNullable : java.lang.Object {
    
    public trait Sub : test.PropagateTypeArgumentNullable.Super {
        public abstract override /*1*/ fun invOutR() : jet.MutableList<jet.List<jet.String?>>
-        public abstract override /*1*/ fun invOutS(/*0*/ p0 : jet.MutableList<jet.List<jet.String?>>) : Unit
+        public abstract override /*1*/ fun invOutS(/*0*/ p0 : jet.MutableList<jet.List<jet.String?>>) : jet.Unit
        public abstract override /*1*/ fun invR() : jet.MutableList<jet.String?>
-        public abstract override /*1*/ fun outOutS(/*0*/ p0 : jet.List<jet.List<jet.String?>>) : Unit
+        public abstract override /*1*/ fun outOutS(/*0*/ p0 : jet.List<jet.List<jet.String?>>) : jet.Unit
        public abstract override /*1*/ fun outR() : jet.List<jet.String?>
-        public abstract override /*1*/ fun outS(/*0*/ p0 : jet.List<jet.String?>) : Unit
+        public abstract override /*1*/ fun outS(/*0*/ p0 : jet.List<jet.String?>) : jet.Unit
    }
    
    public trait Super : java.lang.Object {
        public abstract fun invOutR() : jet.MutableList<jet.List<jet.String?>>
-        public abstract fun invOutS(/*0*/ p0 : jet.MutableList<jet.List<jet.String?>>) : Unit
+        public abstract fun invOutS(/*0*/ p0 : jet.MutableList<jet.List<jet.String?>>) : jet.Unit
        public abstract fun invR() : jet.MutableList<jet.String?>
-        public abstract fun outOutS(/*0*/ p0 : jet.List<jet.List<jet.String?>>) : Unit
+        public abstract fun outOutS(/*0*/ p0 : jet.List<jet.List<jet.String?>>) : jet.Unit
        public abstract fun outR() : jet.List<jet.String?>
-        public abstract fun outS(/*0*/ p0 : jet.List<jet.String?>) : Unit
+        public abstract fun outS(/*0*/ p0 : jet.List<jet.String?>) : jet.Unit
    }
 }
@@ -3,10 +3,10 @@ package test
 public trait ChangeProjectionKind1 : java.lang.Object {
    
    public trait Sub : test.ChangeProjectionKind1.Super {
-        public abstract override /*1*/ fun foo(/*0*/ p0 : jet.MutableList<in jet.String>) : Unit
+        public abstract override /*1*/ fun foo(/*0*/ p0 : jet.MutableList<in jet.String>) : jet.Unit
    }
    
    public trait Super : java.lang.Object {
-        public abstract fun foo(/*0*/ p0 : jet.MutableList<in jet.String>) : Unit
+        public abstract fun foo(/*0*/ p0 : jet.MutableList<in jet.String>) : jet.Unit
    }
 }
@@ -3,10 +3,10 @@ package test
 public trait ChangeProjectionKind2 : java.lang.Object {
    
    public trait Sub : test.ChangeProjectionKind2.Super {
-        public abstract override /*1*/ fun foo(/*0*/ p0 : jet.MutableList<jet.String>) : Unit
+        public abstract override /*1*/ fun foo(/*0*/ p0 : jet.MutableList<jet.String>) : jet.Unit
    }
    
    public trait Super : java.lang.Object {
-        public abstract fun foo(/*0*/ p0 : jet.MutableList<jet.String>) : Unit
+        public abstract fun foo(/*0*/ p0 : jet.MutableList<jet.String>) : jet.Unit
    }
 }
@@ -3,14 +3,14 @@ package test
 public trait DeeplySubstitutedClassParameter : java.lang.Object {
    
    public trait Middle</*0*/ E> : test.DeeplySubstitutedClassParameter.Super<E> {
-        public abstract override /*1*/ fun foo(/*0*/ p0 : E) : Unit
+        public abstract override /*1*/ fun foo(/*0*/ p0 : E) : jet.Unit
    }
    
    public trait Sub : test.DeeplySubstitutedClassParameter.Middle<jet.String> {
-        public abstract override /*1*/ fun foo(/*0*/ p0 : jet.String) : Unit
+        public abstract override /*1*/ fun foo(/*0*/ p0 : jet.String) : jet.Unit
    }
    
    public trait Super</*0*/ T> : java.lang.Object {
-        public abstract fun foo(/*0*/ p0 : T) : Unit
+        public abstract fun foo(/*0*/ p0 : T) : jet.Unit
    }
 }
@@ -3,14 +3,14 @@ package test
 public trait DeeplySubstitutedClassParameter2 : java.lang.Object {
    
    public trait Middle</*0*/ E> : test.DeeplySubstitutedClassParameter2.Super<E> {
-        public abstract override /*1*/ /*fake_override*/ fun foo(/*0*/ p0 : E) : Unit
+        public abstract override /*1*/ /*fake_override*/ fun foo(/*0*/ p0 : E) : jet.Unit
    }
    
    public trait Sub : test.DeeplySubstitutedClassParameter2.Middle<jet.String> {
-        public abstract override /*1*/ fun foo(/*0*/ p0 : jet.String) : Unit
+        public abstract override /*1*/ fun foo(/*0*/ p0 : jet.String) : jet.Unit
    }
    
    public trait Super</*0*/ T> : java.lang.Object {
-        public abstract fun foo(/*0*/ p0 : T) : Unit
+        public abstract fun foo(/*0*/ p0 : T) : jet.Unit
    }
 }
@@ -3,10 +3,10 @@ package test
 public trait InheritMutability : java.lang.Object {
    
    public trait Sub : test.InheritMutability.Super {
-        public abstract override /*1*/ fun foo(/*0*/ p0 : jet.MutableList<jet.String>) : Unit
+        public abstract override /*1*/ fun foo(/*0*/ p0 : jet.MutableList<jet.String>) : jet.Unit
    }
    
    public trait Super : java.lang.Object {
-        public abstract fun foo(/*0*/ p0 : jet.MutableList<jet.String>) : Unit
+        public abstract fun foo(/*0*/ p0 : jet.MutableList<jet.String>) : jet.Unit
    }
 }
@@ -3,10 +3,10 @@ package test
 public trait InheritNotVararg : java.lang.Object {
    
    public trait Sub : test.InheritNotVararg.Super {
-        public abstract override /*1*/ fun foo(/*0*/ p0 : jet.Array<out jet.String>?) : Unit
+        public abstract override /*1*/ fun foo(/*0*/ p0 : jet.Array<out jet.String>?) : jet.Unit
    }
    
    public trait Super : java.lang.Object {
-        public abstract fun foo(/*0*/ p0 : jet.Array<out jet.String>?) : Unit
+        public abstract fun foo(/*0*/ p0 : jet.Array<out jet.String>?) : jet.Unit
    }
 }
@@ -3,10 +3,10 @@ package test
 public trait InheritNotVarargInteger : java.lang.Object {
    
    public trait Sub : test.InheritNotVarargInteger.Super {
-        public abstract override /*1*/ fun foo(/*0*/ p0 : jet.Array<out jet.Int>?) : Unit
+        public abstract override /*1*/ fun foo(/*0*/ p0 : jet.Array<out jet.Int>?) : jet.Unit
    }
    
    public trait Super : java.lang.Object {
-        public abstract fun foo(/*0*/ p0 : jet.Array<out jet.Int>?) : Unit
+        public abstract fun foo(/*0*/ p0 : jet.Array<out jet.Int>?) : jet.Unit
    }
 }
@@ -3,10 +3,10 @@ package test
 public trait InheritNotVarargNotNull : java.lang.Object {
    
    public trait Sub : test.InheritNotVarargNotNull.Super {
-        public abstract override /*1*/ fun foo(/*0*/ p0 : jet.Array<out jet.String>) : Unit
+        public abstract override /*1*/ fun foo(/*0*/ p0 : jet.Array<out jet.String>) : jet.Unit
    }
    
    public trait Super : java.lang.Object {
-        public abstract fun foo(/*0*/ p0 : jet.Array<out jet.String>) : Unit
+        public abstract fun foo(/*0*/ p0 : jet.Array<out jet.String>) : jet.Unit
    }
 }
@@ -3,10 +3,10 @@ package test
 public trait InheritNotVarargPrimitive : java.lang.Object {
    
    public trait Sub : test.InheritNotVarargPrimitive.Super {
-        public abstract override /*1*/ fun foo(/*0*/ p0 : jet.IntArray?) : Unit
+        public abstract override /*1*/ fun foo(/*0*/ p0 : jet.IntArray?) : jet.Unit
    }
    
    public trait Super : java.lang.Object {
-        public abstract fun foo(/*0*/ p0 : jet.IntArray?) : Unit
+        public abstract fun foo(/*0*/ p0 : jet.IntArray?) : jet.Unit
    }
 }
@@ -3,10 +3,10 @@ package test
 public trait InheritNullability : java.lang.Object {
    
    public trait Sub : test.InheritNullability.Super {
-        public abstract override /*1*/ fun foo(/*0*/ p0 : jet.String) : Unit
+        public abstract override /*1*/ fun foo(/*0*/ p0 : jet.String) : jet.Unit
    }
    
    public trait Super : java.lang.Object {
-        public abstract fun foo(/*0*/ p0 : jet.String) : Unit
+        public abstract fun foo(/*0*/ p0 : jet.String) : jet.Unit
    }
 }
@@ -3,10 +3,10 @@ package test
 public trait InheritProjectionKind : java.lang.Object {
    
    public trait Sub : test.InheritProjectionKind.Super {
-        public abstract override /*1*/ fun foo(/*0*/ p0 : jet.MutableList<in jet.String>) : Unit
+        public abstract override /*1*/ fun foo(/*0*/ p0 : jet.MutableList<in jet.String>) : jet.Unit
    }
    
    public trait Super : java.lang.Object {
-        public abstract fun foo(/*0*/ p0 : jet.MutableList<in jet.String>) : Unit
+        public abstract fun foo(/*0*/ p0 : jet.MutableList<in jet.String>) : jet.Unit
    }
 }
@@ -3,10 +3,10 @@ package test
 public trait InheritReadOnliness : java.lang.Object {
    
    public trait Sub : test.InheritReadOnliness.Super {
-        public abstract override /*1*/ fun foo(/*0*/ p0 : jet.List<jet.String>) : Unit
+        public abstract override /*1*/ fun foo(/*0*/ p0 : jet.List<jet.String>) : jet.Unit
    }
    
    public trait Super : java.lang.Object {
-        public abstract fun foo(/*0*/ p0 : jet.List<jet.String>) : Unit
+        public abstract fun foo(/*0*/ p0 : jet.List<jet.String>) : jet.Unit
    }
 }
@@ -3,10 +3,10 @@ package test
 public trait InheritVararg : java.lang.Object {
    
    public trait Sub : test.InheritVararg.Super {
-        public abstract override /*1*/ fun foo(/*0*/ vararg p0 : jet.String? /*jet.Array<jet.String?>*/) : Unit
+        public abstract override /*1*/ fun foo(/*0*/ vararg p0 : jet.String? /*jet.Array<jet.String?>*/) : jet.Unit
    }
    
    public trait Super : java.lang.Object {
-        public abstract fun foo(/*0*/ vararg p0 : jet.String? /*jet.Array<jet.String?>*/) : Unit
+        public abstract fun foo(/*0*/ vararg p0 : jet.String? /*jet.Array<jet.String?>*/) : jet.Unit
    }
 }
@@ -3,10 +3,10 @@ package test
 public trait InheritVarargInteger : java.lang.Object {
    
    public trait Sub : test.InheritVarargInteger.Super {
-        public abstract override /*1*/ fun foo(/*0*/ vararg p0 : jet.Int? /*jet.Array<jet.Int?>*/) : Unit
+        public abstract override /*1*/ fun foo(/*0*/ vararg p0 : jet.Int? /*jet.Array<jet.Int?>*/) : jet.Unit
    }
    
    public trait Super : java.lang.Object {
-        public abstract fun foo(/*0*/ vararg p0 : jet.Int? /*jet.Array<jet.Int?>*/) : Unit
+        public abstract fun foo(/*0*/ vararg p0 : jet.Int? /*jet.Array<jet.Int?>*/) : jet.Unit
    }
 }
@@ -3,10 +3,10 @@ package test
 public trait InheritVarargNotNull : java.lang.Object {
    
    public trait Sub : test.InheritVarargNotNull.Super {
-        public abstract override /*1*/ fun foo(/*0*/ vararg p0 : jet.String /*jet.Array<jet.String>*/) : Unit
+        public abstract override /*1*/ fun foo(/*0*/ vararg p0 : jet.String /*jet.Array<jet.String>*/) : jet.Unit
    }
    
    public trait Super : java.lang.Object {
-        public abstract fun foo(/*0*/ vararg p0 : jet.String /*jet.Array<jet.String>*/) : Unit
+        public abstract fun foo(/*0*/ vararg p0 : jet.String /*jet.Array<jet.String>*/) : jet.Unit
    }
 }
@@ -3,10 +3,10 @@ package test
 public trait InheritVarargPrimitive : java.lang.Object {
    
    public trait Sub : test.InheritVarargPrimitive.Super {
-        public abstract override /*1*/ fun foo(/*0*/ vararg p0 : jet.Int /*jet.IntArray*/) : Unit
+        public abstract override /*1*/ fun foo(/*0*/ vararg p0 : jet.Int /*jet.IntArray*/) : jet.Unit
    }
    
    public trait Super : java.lang.Object {
-        public abstract fun foo(/*0*/ vararg p0 : jet.Int /*jet.IntArray*/) : Unit
+        public abstract fun foo(/*0*/ vararg p0 : jet.Int /*jet.IntArray*/) : jet.Unit
    }
 }
@@ -3,10 +3,10 @@ package test
 public trait MutableToReadOnly : java.lang.Object {
    
    public trait Sub : test.MutableToReadOnly.Super {
-        public abstract override /*1*/ fun foo(/*0*/ p0 : jet.MutableList<jet.String>) : Unit
+        public abstract override /*1*/ fun foo(/*0*/ p0 : jet.MutableList<jet.String>) : jet.Unit
    }
    
    public trait Super : java.lang.Object {
-        public abstract fun foo(/*0*/ p0 : jet.MutableList<jet.String>) : Unit
+        public abstract fun foo(/*0*/ p0 : jet.MutableList<jet.String>) : jet.Unit
    }
 }
@@ -3,10 +3,10 @@ package test
 public trait NotNullToNullable : java.lang.Object {
    
    public trait Sub : test.NotNullToNullable.Super {
-        public abstract override /*1*/ fun foo(/*0*/ p0 : jet.String) : Unit
+        public abstract override /*1*/ fun foo(/*0*/ p0 : jet.String) : jet.Unit
    }
    
    public trait Super : java.lang.Object {
-        public abstract fun foo(/*0*/ p0 : jet.String) : Unit
+        public abstract fun foo(/*0*/ p0 : jet.String) : jet.Unit
    }
 }
@@ -3,10 +3,10 @@ package test
 public trait NullableToNotNull : java.lang.Object {
    
    public trait Sub : test.NullableToNotNull.Super {
-        public abstract override /*1*/ fun foo(/*0*/ p0 : jet.String?) : Unit
+        public abstract override /*1*/ fun foo(/*0*/ p0 : jet.String?) : jet.Unit
    }
    
    public trait Super : java.lang.Object {
-        public abstract fun foo(/*0*/ p0 : jet.String?) : Unit
+        public abstract fun foo(/*0*/ p0 : jet.String?) : jet.Unit
    }
 }
@@ -3,10 +3,10 @@ package test
 public trait NullableToNotNullKotlinSignature : java.lang.Object {
    
    public trait Sub : test.NullableToNotNullKotlinSignature.Super {
-        public abstract override /*1*/ fun foo(/*0*/ p0 : jet.String?) : Unit
+        public abstract override /*1*/ fun foo(/*0*/ p0 : jet.String?) : jet.Unit
    }
    
    public trait Super : java.lang.Object {
-        public abstract fun foo(/*0*/ p0 : jet.String?) : Unit
+        public abstract fun foo(/*0*/ p0 : jet.String?) : jet.Unit
    }
 }
@@ -3,10 +3,10 @@ package test
 public trait OverrideWithErasedParameter : java.lang.Object {
    
    public trait Sub</*0*/ T> : test.OverrideWithErasedParameter.Super<T> {
-        public abstract override /*1*/ fun foo(/*0*/ p0 : T?) : Unit
+        public abstract override /*1*/ fun foo(/*0*/ p0 : T?) : jet.Unit
    }
    
    public trait Super</*0*/ T> : java.lang.Object {
-        public abstract fun foo(/*0*/ p0 : T?) : Unit
+        public abstract fun foo(/*0*/ p0 : T?) : jet.Unit
    }
 }
@@ -3,10 +3,10 @@ package test
 public trait ReadOnlyToMutable : java.lang.Object {
    
    public trait Sub : test.ReadOnlyToMutable.Super {
-        public abstract override /*1*/ fun foo(/*0*/ p0 : jet.List<jet.String>) : Unit
+        public abstract override /*1*/ fun foo(/*0*/ p0 : jet.List<jet.String>) : jet.Unit
    }
    
    public trait Super : java.lang.Object {
-        public abstract fun foo(/*0*/ p0 : jet.List<jet.String>) : Unit
+        public abstract fun foo(/*0*/ p0 : jet.List<jet.String>) : jet.Unit
    }
 }
@@ -3,14 +3,14 @@ package test
 public trait SubclassFromGenericAndNot : java.lang.Object {
    
    public trait Generic</*0*/ T> : java.lang.Object {
-        public abstract fun foo(/*0*/ p0 : T) : Unit
+        public abstract fun foo(/*0*/ p0 : T) : jet.Unit
    }
    
    public trait NonGeneric : java.lang.Object {
-        public abstract fun foo(/*0*/ p0 : jet.String) : Unit
+        public abstract fun foo(/*0*/ p0 : jet.String) : jet.Unit
    }
    
    public trait Sub : test.SubclassFromGenericAndNot.NonGeneric, test.SubclassFromGenericAndNot.Generic<jet.String> {
-        public abstract override /*2*/ fun foo(/*0*/ p0 : jet.String) : Unit
+        public abstract override /*2*/ fun foo(/*0*/ p0 : jet.String) : jet.Unit
    }
 }
@@ -3,10 +3,10 @@ package test
 public trait SubstitutedClassParameter : java.lang.Object {
    
    public trait Sub : test.SubstitutedClassParameter.Super<jet.String> {
-        public abstract override /*1*/ fun foo(/*0*/ p0 : jet.String) : Unit
+        public abstract override /*1*/ fun foo(/*0*/ p0 : jet.String) : jet.Unit
    }
    
    public trait Super</*0*/ T> : java.lang.Object {
-        public abstract fun foo(/*0*/ p0 : T) : Unit
+        public abstract fun foo(/*0*/ p0 : T) : jet.Unit
    }
 }
@@ -3,14 +3,14 @@ package test
 public trait SubstitutedClassParameters : java.lang.Object {
    
    public trait Sub : test.SubstitutedClassParameters.Super1<jet.String>, test.SubstitutedClassParameters.Super2<jet.String> {
-        public abstract override /*2*/ fun foo(/*0*/ p0 : jet.String) : Unit
+        public abstract override /*2*/ fun foo(/*0*/ p0 : jet.String) : jet.Unit
    }
    
    public trait Super1</*0*/ T> : java.lang.Object {
-        public abstract fun foo(/*0*/ p0 : T) : Unit
+        public abstract fun foo(/*0*/ p0 : T) : jet.Unit
    }
    
    public trait Super2</*0*/ E> : java.lang.Object {
-        public abstract fun foo(/*0*/ p0 : E) : Unit
+        public abstract fun foo(/*0*/ p0 : E) : jet.Unit
    }
 }
@@ -12,10 +12,10 @@ public trait HalfSubstitutedTypeParameters : java.lang.Object {
    
    public trait TrickyList</*0*/ X, /*1*/ E> : jet.MutableList<E> {
        public abstract override /*1*/ /*fake_override*/ fun add(/*0*/ e : E) : jet.Boolean
-        public abstract override /*1*/ /*fake_override*/ fun add(/*0*/ index : jet.Int, /*1*/ element : E) : Unit
+        public abstract override /*1*/ /*fake_override*/ fun add(/*0*/ index : jet.Int, /*1*/ element : E) : jet.Unit
        public abstract override /*1*/ /*fake_override*/ fun addAll(/*0*/ c : jet.Collection<E>) : jet.Boolean
        public abstract override /*1*/ /*fake_override*/ fun addAll(/*0*/ index : jet.Int, /*1*/ c : jet.Collection<E>) : jet.Boolean
-        public abstract override /*1*/ /*fake_override*/ fun clear() : Unit
+        public abstract override /*1*/ /*fake_override*/ fun clear() : jet.Unit
        public abstract override /*1*/ /*fake_override*/ fun contains(/*0*/ o : jet.Any?) : jet.Boolean
        public abstract override /*1*/ /*fake_override*/ fun containsAll(/*0*/ c : jet.Collection<jet.Any?>) : jet.Boolean
        public abstract override /*1*/ /*fake_override*/ fun get(/*0*/ index : jet.Int) : E
@@ -3,7 +3,7 @@ package test
 public trait SubclassOfCollection</*0*/ E> : jet.MutableCollection<E> {
    public abstract override /*1*/ /*fake_override*/ fun add(/*0*/ e : E) : jet.Boolean
    public abstract override /*1*/ /*fake_override*/ fun addAll(/*0*/ c : jet.Collection<E>) : jet.Boolean
-    public abstract override /*1*/ /*fake_override*/ fun clear() : Unit
+    public abstract override /*1*/ /*fake_override*/ fun clear() : jet.Unit
    public abstract override /*1*/ /*fake_override*/ fun contains(/*0*/ o : jet.Any?) : jet.Boolean
    public abstract override /*1*/ /*fake_override*/ fun containsAll(/*0*/ c : jet.Collection<jet.Any?>) : jet.Boolean
    public abstract override /*1*/ /*fake_override*/ fun isEmpty() : jet.Boolean
@@ -3,10 +3,10 @@ package test
 public trait InheritMutability : java.lang.Object {
    
    public trait Sub : test.InheritMutability.Super {
-        public abstract override /*1*/ fun </*0*/ B : jet.MutableList<jet.String>> foo(/*0*/ p0 : B) : Unit
+        public abstract override /*1*/ fun </*0*/ B : jet.MutableList<jet.String>> foo(/*0*/ p0 : B) : jet.Unit
    }
    
    public trait Super : java.lang.Object {
-        public abstract fun </*0*/ A : jet.MutableList<jet.String>> foo(/*0*/ p0 : A) : Unit
+        public abstract fun </*0*/ A : jet.MutableList<jet.String>> foo(/*0*/ p0 : A) : jet.Unit
    }
 }
@@ -3,10 +3,10 @@ package test
 public trait InheritNullability : java.lang.Object {
    
    public trait Sub : test.InheritNullability.Super {
-        public abstract override /*1*/ fun </*0*/ B : jet.CharSequence> foo(/*0*/ p0 : B) : Unit
+        public abstract override /*1*/ fun </*0*/ B : jet.CharSequence> foo(/*0*/ p0 : B) : jet.Unit
    }
    
    public trait Super : java.lang.Object {
-        public abstract fun </*0*/ A : jet.CharSequence> foo(/*0*/ p0 : A) : Unit
+        public abstract fun </*0*/ A : jet.CharSequence> foo(/*0*/ p0 : A) : jet.Unit
    }
 }
@@ -3,10 +3,10 @@ package test
 public trait InheritReadOnliness : java.lang.Object {
    
    public trait Sub : test.InheritReadOnliness.Super {
-        public abstract override /*1*/ fun </*0*/ B : jet.List<jet.String>> foo(/*0*/ p0 : B) : Unit
+        public abstract override /*1*/ fun </*0*/ B : jet.List<jet.String>> foo(/*0*/ p0 : B) : jet.Unit
    }
    
    public trait Super : java.lang.Object {
-        public abstract fun </*0*/ A : jet.List<jet.String>> foo(/*0*/ p0 : A) : Unit
+        public abstract fun </*0*/ A : jet.List<jet.String>> foo(/*0*/ p0 : A) : jet.Unit
    }
 }
@@ -3,10 +3,10 @@ package test
 public trait TwoBounds : java.lang.Object {
    
    public trait Sub : test.TwoBounds.Super {
-        public abstract override /*1*/ fun </*0*/ B> foo(/*0*/ p0 : B) : Unit where B : jet.CharSequence, B : java.lang.Cloneable
+        public abstract override /*1*/ fun </*0*/ B> foo(/*0*/ p0 : B) : jet.Unit where B : jet.CharSequence, B : java.lang.Cloneable
    }
    
    public trait Super : java.lang.Object {
-        public abstract fun </*0*/ A> foo(/*0*/ p0 : A) : Unit where A : jet.CharSequence, A : java.lang.Cloneable
+        public abstract fun </*0*/ A> foo(/*0*/ p0 : A) : jet.Unit where A : jet.CharSequence, A : java.lang.Cloneable
    }
 }
@@ -3,14 +3,14 @@ package test
 public trait TwoSuperclasses : java.lang.Object {
    
    public trait Sub : test.TwoSuperclasses.Super1, test.TwoSuperclasses.Super2 {
-        public abstract override /*2*/ fun </*0*/ C : jet.CharSequence> foo(/*0*/ p0 : C) : Unit
+        public abstract override /*2*/ fun </*0*/ C : jet.CharSequence> foo(/*0*/ p0 : C) : jet.Unit
    }
    
    public trait Super1 : java.lang.Object {
-        public abstract fun </*0*/ A : jet.CharSequence> foo(/*0*/ p0 : A) : Unit
+        public abstract fun </*0*/ A : jet.CharSequence> foo(/*0*/ p0 : A) : jet.Unit
    }
    
    public trait Super2 : java.lang.Object {
-        public abstract fun </*0*/ B : jet.CharSequence> foo(/*0*/ p0 : B) : Unit
+        public abstract fun </*0*/ B : jet.CharSequence> foo(/*0*/ p0 : B) : jet.Unit
    }
 }
@@ -3,10 +3,10 @@ package test
 public trait TwoTypeParameters : java.lang.Object {
    
    public trait Sub : test.TwoTypeParameters.Super {
-        public abstract override /*1*/ fun </*0*/ B : jet.CharSequence, /*1*/ A : java.lang.Cloneable> foo(/*0*/ p0 : B, /*1*/ p1 : A) : Unit
+        public abstract override /*1*/ fun </*0*/ B : jet.CharSequence, /*1*/ A : java.lang.Cloneable> foo(/*0*/ p0 : B, /*1*/ p1 : A) : jet.Unit
    }
    
    public trait Super : java.lang.Object {
-        public abstract fun </*0*/ A : jet.CharSequence, /*1*/ B : java.lang.Cloneable> foo(/*0*/ p0 : A, /*1*/ p1 : B) : Unit
+        public abstract fun </*0*/ A : jet.CharSequence, /*1*/ B : java.lang.Cloneable> foo(/*0*/ p0 : A, /*1*/ p1 : B) : jet.Unit
    }
 }
@@ -3,10 +3,10 @@ package test
 public trait UseParameterAsUpperBound : java.lang.Object {
    
    public trait Sub : test.UseParameterAsUpperBound.Super {
-        public abstract override /*1*/ fun </*0*/ B, /*1*/ A : B> foo(/*0*/ p0 : B, /*1*/ p1 : A) : Unit
+        public abstract override /*1*/ fun </*0*/ B, /*1*/ A : B> foo(/*0*/ p0 : B, /*1*/ p1 : A) : jet.Unit
    }
    
    public trait Super : java.lang.Object {
-        public abstract fun </*0*/ A, /*1*/ B : A> foo(/*0*/ p0 : A, /*1*/ p1 : B) : Unit
+        public abstract fun </*0*/ A, /*1*/ B : A> foo(/*0*/ p0 : A, /*1*/ p1 : B) : jet.Unit
    }
 }
@@ -3,10 +3,10 @@ package test
 public trait UseParameterInUpperBound : java.lang.Object {
    
    public trait Sub : test.UseParameterInUpperBound.Super {
-        public abstract override /*1*/ fun </*0*/ B, /*1*/ A : jet.List<B>> foo(/*0*/ p0 : B, /*1*/ p1 : A) : Unit
+        public abstract override /*1*/ fun </*0*/ B, /*1*/ A : jet.List<B>> foo(/*0*/ p0 : B, /*1*/ p1 : A) : jet.Unit
    }
    
    public trait Super : java.lang.Object {
-        public abstract fun </*0*/ A, /*1*/ B : jet.List<A>> foo(/*0*/ p0 : A, /*1*/ p1 : B) : Unit
+        public abstract fun </*0*/ A, /*1*/ B : jet.List<A>> foo(/*0*/ p0 : A, /*1*/ p1 : B) : jet.Unit
    }
 }
@@ -3,10 +3,10 @@ package test
 public trait UseParameterInUpperBoundWithKotlinSignature : java.lang.Object {
    
    public trait Sub : test.UseParameterInUpperBoundWithKotlinSignature.Super {
-        public abstract override /*1*/ fun </*0*/ B, /*1*/ A : jet.List<B>> foo(/*0*/ p0 : B, /*1*/ p1 : A) : Unit
+        public abstract override /*1*/ fun </*0*/ B, /*1*/ A : jet.List<B>> foo(/*0*/ p0 : B, /*1*/ p1 : A) : jet.Unit
    }
    
    public trait Super : java.lang.Object {
-        public abstract fun </*0*/ A, /*1*/ B : jet.List<A>> foo(/*0*/ p0 : A, /*1*/ p1 : B) : Unit
+        public abstract fun </*0*/ A, /*1*/ B : jet.List<A>> foo(/*0*/ p0 : A, /*1*/ p1 : B) : jet.Unit
    }
 }
@@ -2,5 +2,5 @@ package test

 public trait LoadIterable</*0*/ T> : java.lang.Object {
    public abstract fun getIterable() : jet.MutableIterable<T>?
-    public abstract fun setIterable(/*0*/ p0 : jet.Iterable<T>?) : Unit
+    public abstract fun setIterable(/*0*/ p0 : jet.Iterable<T>?) : jet.Unit
 }
@@ -2,5 +2,5 @@ package test

 public trait LoadIterator</*0*/ T> : java.lang.Object {
    public abstract fun getIterator() : jet.MutableIterator<T>?
-    public abstract fun setIterator(/*0*/ p0 : jet.Iterator<T>?) : Unit
+    public abstract fun setIterator(/*0*/ p0 : jet.Iterator<T>?) : jet.Unit
 }
@@ -3,11 +3,11 @@ package test
 public open class ModalityOfFakeOverrides : java.util.AbstractList<jet.String> {
    public constructor ModalityOfFakeOverrides()
    protected final override /*1*/ /*fake_override*/ var modCount : jet.Int
-    public open override /*1*/ /*fake_override*/ fun add(/*0*/ p0 : jet.Int, /*1*/ p1 : jet.String) : Unit
+    public open override /*1*/ /*fake_override*/ fun add(/*0*/ p0 : jet.Int, /*1*/ p1 : jet.String) : jet.Unit
    public open override /*1*/ /*fake_override*/ fun add(/*0*/ p0 : jet.String) : jet.Boolean
    public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ p0 : jet.Collection<jet.String>) : jet.Boolean
    public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ p0 : jet.Int, /*1*/ p1 : jet.Collection<jet.String>) : jet.Boolean
-    public open override /*1*/ /*fake_override*/ fun clear() : Unit
+    public open override /*1*/ /*fake_override*/ fun clear() : jet.Unit
    public open override /*1*/ /*fake_override*/ fun contains(/*0*/ p0 : jet.Any?) : jet.Boolean
    public open override /*1*/ /*fake_override*/ fun containsAll(/*0*/ p0 : jet.Collection<jet.Any?>) : jet.Boolean
    public open override /*1*/ fun get(/*0*/ p0 : jet.Int) : jet.String
@@ -20,7 +20,7 @@ public open class ModalityOfFakeOverrides : java.util.AbstractList<jet.String> {
    public open override /*1*/ /*fake_override*/ fun remove(/*0*/ p0 : jet.Any?) : jet.Boolean
    public open override /*1*/ /*fake_override*/ fun remove(/*0*/ p0 : jet.Int) : jet.String
    public open override /*1*/ /*fake_override*/ fun removeAll(/*0*/ p0 : jet.Collection<jet.Any?>) : jet.Boolean
-    protected open override /*1*/ /*fake_override*/ fun removeRange(/*0*/ p0 : jet.Int, /*1*/ p1 : jet.Int) : Unit
+    protected open override /*1*/ /*fake_override*/ fun removeRange(/*0*/ p0 : jet.Int, /*1*/ p1 : jet.Int) : jet.Unit
    public open override /*1*/ /*fake_override*/ fun retainAll(/*0*/ p0 : jet.Collection<jet.Any?>) : jet.Boolean
    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
@@ -2,5 +2,5 @@ package test

 public open class NotNullParameter : java.lang.Object {
    public constructor NotNullParameter()
-    public open fun hi(/*0*/ p0 : jet.String) : Unit
+    public open fun hi(/*0*/ p0 : jet.String) : jet.Unit
 }
@@ -2,5 +2,5 @@ package test

 public open class VarargInt : java.lang.Object {
    public constructor VarargInt()
-    public open fun vararg(/*0*/ vararg p0 : jet.Int /*jet.IntArray*/) : Unit
+    public open fun vararg(/*0*/ vararg p0 : jet.Int /*jet.IntArray*/) : jet.Unit
 }
@@ -2,5 +2,5 @@ package test

 public open class VarargString : java.lang.Object {
    public constructor VarargString()
-    public open fun vararg(/*0*/ vararg p0 : jet.String? /*jet.Array<jet.String?>*/) : Unit
+    public open fun vararg(/*0*/ vararg p0 : jet.String? /*jet.Array<jet.String?>*/) : jet.Unit
 }
@@ -2,10 +2,10 @@ package test

 public open class Base : java.lang.Object {
    public constructor Base()
-    public/*package*/ open fun foo() : Unit
+    public/*package*/ open fun foo() : jet.Unit
 }

 internal final class Derived : test.Base {
    public constructor Derived()
-    internal open override /*1*/ fun foo() : Unit
+    internal open override /*1*/ fun foo() : jet.Unit
 }
@@ -2,10 +2,10 @@ package test

 public open class Base : java.lang.Object {
    public constructor Base()
-    protected/*protected and package*/ open fun foo() : Unit
+    protected/*protected and package*/ open fun foo() : jet.Unit
 }

 internal final class Derived : test.Base {
    public constructor Derived()
-    protected open override /*1*/ fun foo() : Unit
+    protected open override /*1*/ fun foo() : jet.Unit
 }
@@ -3,13 +3,13 @@ package test
 public trait ErrorTypes : java.lang.Object {
    
    public trait Sub : test.ErrorTypes.Super {
-        public abstract fun errorTypeInParameter(/*0*/ list : jet.List<jet.Array<[ERROR : Unresolved java class: T]>?>?) : Unit
-        public abstract override /*1*/ /*fake_override*/ fun errorTypeInParameter(/*0*/ list : jet.List<jet.Array<[ERROR : Unresolved java class: T]>?>?) : Unit
+        public abstract fun errorTypeInParameter(/*0*/ list : jet.List<jet.Array<[ERROR : Unresolved java class: T]>?>?) : jet.Unit
+        public abstract override /*1*/ /*fake_override*/ fun errorTypeInParameter(/*0*/ list : jet.List<jet.Array<[ERROR : Unresolved java class: T]>?>?) : jet.Unit
        public abstract override /*1*/ fun returnErrorType() : [ERROR : Unresolved java class: T]
    }
    
    public trait Super : java.lang.Object {
-        public abstract fun errorTypeInParameter(/*0*/ list : jet.List<jet.Array<[ERROR : Unresolved java class: T]>?>?) : Unit
+        public abstract fun errorTypeInParameter(/*0*/ list : jet.List<jet.Array<[ERROR : Unresolved java class: T]>?>?) : jet.Unit
        public abstract fun returnErrorType() : [ERROR : Unresolved java class: T]
    }
 }
@@ -6,13 +6,13 @@ public trait ReturnNotSubtype : java.lang.Object {
        public abstract override /*1*/ fun _void() : jet.Boolean
        public abstract override /*1*/ fun array() : jet.Array<java.lang.Void>?
        public abstract override /*1*/ fun klass() : java.lang.Class<out jet.Any?>?
-        public abstract override /*1*/ fun string1() : Unit
+        public abstract override /*1*/ fun string1() : jet.Unit
        public abstract override /*1*/ fun string2() : jet.MutableList<jet.Boolean>?
        public abstract override /*1*/ fun t() : java.lang.Void?
    }
    
    public trait Super</*0*/ T> : java.lang.Object {
-        public abstract fun _void() : Unit
+        public abstract fun _void() : jet.Unit
        public abstract fun array() : jet.Array<T>?
        public abstract fun klass() : java.lang.Class<out jet.CharSequence?>?
        public abstract fun string1() : jet.String?
@@ -1,5 +1,5 @@
 package test

 internal final class A {
-    /*primary*/ public constructor A(/*0*/ vararg a : jet.Int /*jet.IntArray*/, /*1*/ f : () -> Unit)
+    /*primary*/ public constructor A(/*0*/ vararg a : jet.Int /*jet.IntArray*/, /*1*/ f : () -> jet.Unit)
 }
@@ -1,6 +1,6 @@
 package test

-internal fun </*0*/ T> foo() : Unit where T : test.Foo, T : test.Bar
+internal fun </*0*/ T> foo() : jet.Unit where T : test.Foo, T : test.Bar

 internal trait Bar {
 }
@@ -3,5 +3,5 @@ package test
 internal final class ClassFunGetFoo {
    /*primary*/ public constructor ClassFunGetFoo()
    internal final fun getFoo() : jet.Int
-    internal final fun setFoo(/*0*/ p : jet.Int) : Unit
+    internal final fun setFoo(/*0*/ p : jet.Int) : jet.Unit
 }
@@ -2,5 +2,5 @@ package test

 internal final class ClassFunGetFoo {
    /*primary*/ public constructor ClassFunGetFoo()
-    internal final fun set(/*0*/ p : jet.Int) : Unit
+    internal final fun set(/*0*/ p : jet.Int) : jet.Unit
 }
@@ -1,4 +1,4 @@
 package test

-internal fun f(/*0*/ vararg t : jet.String /*jet.Array<jet.String>*/, /*1*/ f : () -> Unit) : Unit
-internal fun f(/*0*/ vararg t : jet.Int /*jet.IntArray*/, /*1*/ f : () -> Unit) : Unit
+internal fun f(/*0*/ vararg t : jet.String /*jet.Array<jet.String>*/, /*1*/ f : () -> jet.Unit) : jet.Unit
+internal fun f(/*0*/ vararg t : jet.Int /*jet.IntArray*/, /*1*/ f : () -> jet.Unit) : jet.Unit
@@ -1,3 +1,3 @@
 package test

-internal fun unit() : Unit
+internal fun unit() : jet.Unit
@@ -37,13 +37,13 @@ public trait TwoUpperBounds<T> where T: Number, T: Any
 //<X> defined in rendererTest.TheClass
 //private final val privateVal : jet.Int defined in rendererTest.TheClass
 //internal final val shouldBeFinal : jet.Int defined in rendererTest.TheClass
-//protected abstract fun foo() : Unit defined in rendererTest.TheClass
+//protected abstract fun foo() : jet.Unit defined in rendererTest.TheClass
 //private final class Inner defined in rendererTest.TheClass
 //public constructor Inner() defined in rendererTest.TheClass.Inner
 //internal final class InternalClass defined in rendererTest
 //public constructor InternalClass() defined in rendererTest.InternalClass
 //internal trait TheTrait defined in rendererTest
-//internal abstract fun abstractFun() : Unit defined in rendererTest.TheTrait
+//internal abstract fun abstractFun() : jet.Unit defined in rendererTest.TheTrait
 //internal class object : rendererTest.TheClass<jet.Int, jet.Int> defined in rendererTest.TheTrait
 //private constructor <class-object-for-TheTrait>() defined in rendererTest.TheTrait.<class-object-for-TheTrait>
 //internal final fun classObjectFunction() : jet.Int defined in rendererTest.TheTrait.<class-object-for-TheTrait>
@@ -8,11 +8,11 @@ var v6  : Int.(String, Int) -> Unit
 var v7  : ExtensionFunction1<Int, String, Boolean>


-//internal var v1 : () -> Unit defined in root package
+//internal var v1 : () -> jet.Unit defined in root package
 //internal var v2 : (jet.Int) -> jet.Int defined in root package
 //internal var v3 : (jet.Int, jet.String) -> jet.String defined in root package
 //internal var v4 : (jet.Int) -> jet.String defined in root package
-//internal var v4 : (() -> jet.Int, (jet.String) -> Unit) -> jet.String defined in root package
+//internal var v4 : (() -> jet.Int, (jet.String) -> jet.Unit) -> jet.String defined in root package
 //internal var v5 : jet.Int.() -> jet.Int defined in root package
-//internal var v6 : jet.Int.(jet.String, jet.Int) -> Unit defined in root package
+//internal var v6 : jet.Int.(jet.String, jet.Int) -> jet.Unit defined in root package
 //internal var v7 : jet.Int.(jet.String) -> jet.Boolean defined in root package
@@ -20,7 +20,7 @@ fun <P> funTypeParameterWithTwoUpperBounds() where P : Foo, P : Bar = 17
 deprecated("") fun deprecatedFun()

 //package rendererTest defined in root package
-//public fun pub() : Unit defined in rendererTest
+//public fun pub() : jet.Unit defined in rendererTest
 //internal fun int() : jet.String defined in rendererTest
 //internal fun int2(vararg ints : jet.Int) : jet.Int defined in rendererTest
 //value-parameter vararg val ints : jet.Int defined in rendererTest.int2
@@ -35,4 +35,4 @@ deprecated("") fun deprecatedFun()
 //internal trait Bar defined in rendererTest
 //internal fun <P> funTypeParameterWithTwoUpperBounds() : jet.Int where P : rendererTest.Foo, P : rendererTest.Bar defined in rendererTest
 //<P : rendererTest.Foo & rendererTest.Bar> defined in rendererTest.funTypeParameterWithTwoUpperBounds
-//jet.deprecated internal fun deprecatedFun() : Unit defined in rendererTest
+//jet.deprecated internal fun deprecatedFun() : jet.Unit defined in rendererTest
@@ -18,13 +18,13 @@ class B : A {
 //internal trait A defined in root package
 //internal abstract val v : jet.Int defined in A
 //public abstract var int : jet.Int defined in A
-//private abstract fun <set-int>(<set-?> : jet.Int) : Unit defined in A
+//private abstract fun <set-int>(<set-?> : jet.Int) : jet.Unit defined in A
 //protected abstract fun f() : jet.Int defined in A
 //internal final class B : A defined in root package
 //public constructor B() defined in B
 //public open var int : jet.Int defined in B
 //public open fun <get-int>() : jet.Int defined in B
-//private open fun <set-int>(<set-?> : jet.Int) : Unit defined in B
+//private open fun <set-int>(<set-?> : jet.Int) : jet.Unit defined in B
 //protected open fun f() : jet.Int defined in B
 //internal open val v : jet.Int defined in B
 //internal open fun <get-v>() : jet.Int defined in B
@@ -1,5 +1,5 @@
 var v1 : Unit
 var v2 : Unit?

-//internal var v1 : Unit defined in root package
-//internal var v2 : Unit? defined in root package
+//internal var v1 : jet.Unit defined in root package
+//internal var v2 : jet.Unit? defined in root package
@@ -20,7 +20,7 @@ t : T</td>
 <td style="white-space:nowrap;font-weight:bold;">
 )</td>
 <td style="white-space:nowrap;font-weight:bold;">
- : Unit <b>
+ : jet.Unit <b>
 where</b>
 E : java.lang.Cloneable, E : java.io.Closeable</td>
 </tr>
@@ -20,7 +20,7 @@ list : T</td>
 <td style="white-space:nowrap;font-weight:bold;">
 )</td>
 <td style="white-space:nowrap;font-weight:bold;">
- : Unit</td>
+ : jet.Unit</td>
 </tr>
 </table>
 is not satisfied: inferred type <font color=red>
@@ -16,7 +16,7 @@ package testData.libraries

    [public open var openVarWithGetter : jet.String] /* compiled code */

-    [public abstract fun abstractFun() : Unit]
+    [public abstract fun abstractFun() : jet.Unit]

-    [public open fun openFun() : Unit { /* compiled code */ }]
+    [public open fun openFun() : jet.Unit { /* compiled code */ }]
 }]]
@@ -13,24 +13,24 @@ package testData.libraries

 [public val <T> testData.libraries.Pair<T, T>.exProp : jet.String] /* compiled code */

-[public fun <T : jet.CharSequence> funWithTypeParam(t : T) : Unit { /* compiled code */ }]
+[public fun <T : jet.CharSequence> funWithTypeParam(t : T) : jet.Unit { /* compiled code */ }]

-[public fun <T : jet.Number> funWithTypeParam(t : T) : Unit { /* compiled code */ }]
+[public fun <T : jet.Number> funWithTypeParam(t : T) : jet.Unit { /* compiled code */ }]

-[public fun func() : Unit { /* compiled code */ }]
+[public fun func() : jet.Unit { /* compiled code */ }]

-[public fun func(cs : jet.CharSequence) : Unit { /* compiled code */ }]
+[public fun func(cs : jet.CharSequence) : jet.Unit { /* compiled code */ }]

-[public fun func(a : jet.Int, b : jet.Int) : Unit { /* compiled code */ }]
+[public fun func(a : jet.Int, b : jet.Int) : jet.Unit { /* compiled code */ }]

-[public fun func(a : jet.Int, b : jet.String = /* compiled code */) : Unit { /* compiled code */ }]
+[public fun func(a : jet.Int, b : jet.String = /* compiled code */) : jet.Unit { /* compiled code */ }]

-[public fun func(str : jet.String) : Unit { /* compiled code */ }]
+[public fun func(str : jet.String) : jet.Unit { /* compiled code */ }]

-[public fun main(args : jet.Array<jet.String>) : Unit { /* compiled code */ }]
+[public fun main(args : jet.Array<jet.String>) : jet.Unit { /* compiled code */ }]

-[public fun processDouble(d : jet.Double) : Unit { /* compiled code */ }]
+[public fun processDouble(d : jet.Double) : jet.Unit { /* compiled code */ }]

-[public fun processDouble(d : testData.libraries.Double) : Unit { /* compiled code */ }]
+[public fun processDouble(d : testData.libraries.Double) : jet.Unit { /* compiled code */ }]

 [public fun <T> T.filter(predicate : (T) -> jet.Boolean) : T? { /* compiled code */ }]
@@ -5,12 +5,12 @@ package testData.libraries

 [[public final class WithInnerAndObject() {
    public class object {
-        [internal final fun foo() : Unit { /* compiled code */ }]
+        [internal final fun foo() : jet.Unit { /* compiled code */ }]
    }

    [[internal final class MyInner() {
        [internal trait MyInnerInner {
-            [internal abstract fun innerInnerMethod() : Unit]
+            [internal abstract fun innerInnerMethod() : jet.Unit]
        }]
    }]]
 }]]