Support for checking loaded descriptors agains an expected txt file

2012-07-11 19:51:56 +04:00
parent 7cf9eeee65
commit 44d92d8eb3
411 changed files with 5050 additions and 8 deletions
@@ -0,0 +1,38 @@
+namespace <root>
+
+// <namespace name="abstract">
+namespace abstract
+
+internal abstract class abstract.MyAbstractClass : jet.Any {
+    public final /*constructor*/ fun <init>(): abstract.MyAbstractClass
+    internal final val a1: jet.Int
+    internal abstract val a2: jet.Int
+    internal abstract val a3: jet.Int
+    internal final val a: jet.Int
+    internal final var b1: jet.Int private set
+    internal abstract var b2: jet.Int private set
+    internal abstract var b3: jet.Int private set
+    internal final var b: jet.Int private set
+    internal final var c1: jet.Int
+    internal abstract var c2: jet.Int
+    internal abstract var c3: jet.Int
+    internal final var c: jet.Int
+    internal final val e1: jet.Int
+    internal abstract val e2: jet.Int
+    internal abstract val e3: jet.Int
+    internal final val e: jet.Int
+    internal final fun f(): jet.Tuple0
+    internal final fun g(): jet.Tuple0
+    internal abstract fun h(): jet.Tuple0
+    internal final var i1: jet.Int
+    internal final var i: jet.Int
+    internal abstract fun j(): jet.Tuple0
+    internal final var j1: jet.Int
+    internal final var j: jet.Int
+    internal final var k1: jet.Int
+    internal final var k: jet.Int
+    internal final var l1: jet.Int
+    internal final var l: jet.Int
+    internal final var n: jet.Int
+}
+// </namespace name="abstract">
@@ -0,0 +1,38 @@
+namespace <root>
+
+// <namespace name="abstract">
+namespace abstract
+
+internal final class abstract.MyClass : jet.Any {
+    public final /*constructor*/ fun <init>(): abstract.MyClass
+    internal final val a1: jet.Int
+    internal abstract val a2: jet.Int
+    internal abstract val a3: jet.Int
+    internal final val a: jet.Int
+    internal final var b1: jet.Int private set
+    internal abstract var b2: jet.Int private set
+    internal abstract var b3: jet.Int private set
+    internal final var b: jet.Int private set
+    internal final var c1: jet.Int
+    internal abstract var c2: jet.Int
+    internal abstract var c3: jet.Int
+    internal final var c: jet.Int
+    internal final val e1: jet.Int
+    internal abstract val e2: jet.Int
+    internal abstract val e3: jet.Int
+    internal final val e: jet.Int
+    internal final fun f(): jet.Tuple0
+    internal final fun g(): jet.Tuple0
+    internal abstract fun h(): jet.Tuple0
+    internal final var i1: jet.Int
+    internal final var i: jet.Int
+    internal abstract fun j(): jet.Tuple0
+    internal final var j1: jet.Int
+    internal final var j: jet.Int
+    internal final var k1: jet.Int
+    internal final var k: jet.Int
+    internal final var l1: jet.Int
+    internal final var l: jet.Int
+    internal final var n: jet.Int
+}
+// </namespace name="abstract">
@@ -0,0 +1,41 @@
+namespace <root>
+
+// <namespace name="abstract">
+namespace abstract
+
+internal final enum class abstract.MyEnum : jet.Any {
+    public final /*constructor*/ fun <init>(): abstract.MyEnum
+    internal final val a1: jet.Int
+    internal abstract val a2: jet.Int
+    internal abstract val a3: jet.Int
+    internal final val a: jet.Int
+    internal final var b1: jet.Int private set
+    internal abstract var b2: jet.Int private set
+    internal abstract var b3: jet.Int private set
+    internal final var b: jet.Int private set
+    internal final var c1: jet.Int
+    internal abstract var c2: jet.Int
+    internal abstract var c3: jet.Int
+    internal final var c: jet.Int
+    internal final val e1: jet.Int
+    internal abstract val e2: jet.Int
+    internal abstract val e3: jet.Int
+    internal final val e: jet.Int
+    internal final fun f(): jet.Tuple0
+    internal final fun g(): jet.Tuple0
+    internal abstract fun h(): jet.Tuple0
+    internal final var i1: jet.Int
+    internal final var i: jet.Int
+    internal abstract fun j(): jet.Tuple0
+    internal final var j1: jet.Int
+    internal final var j: jet.Int
+    internal final var k1: jet.Int
+    internal final var k: jet.Int
+    internal final var l1: jet.Int
+    internal final var l: jet.Int
+    internal final var n: jet.Int
+    internal final object abstract.MyEnum.<class-object-for-MyEnum> {
+        internal final /*constructor*/ fun <init>(): abstract.MyEnum.<class-object-for-MyEnum>
+    }
+}
+// </namespace name="abstract">
@@ -0,0 +1,37 @@
+namespace <root>
+
+// <namespace name="abstract">
+namespace abstract
+
+internal abstract trait abstract.MyTrait : jet.Any {
+    internal open val a1: jet.Int
+    internal abstract val a2: jet.Int
+    internal abstract val a3: jet.Int
+    internal abstract val a: jet.Int
+    internal open var b1: jet.Int private set
+    internal abstract var b2: jet.Int private set
+    internal abstract var b3: jet.Int private set
+    internal abstract var b: jet.Int private set
+    internal open var c1: jet.Int
+    internal abstract var c2: jet.Int
+    internal abstract var c3: jet.Int
+    internal open var c: jet.Int
+    internal open val e1: jet.Int
+    internal abstract val e2: jet.Int
+    internal abstract val e3: jet.Int
+    internal open val e: jet.Int
+    internal abstract fun f(): jet.Tuple0
+    internal open fun g(): jet.Tuple0
+    internal abstract fun h(): jet.Tuple0
+    internal open var i1: jet.Int
+    internal abstract var i: jet.Int
+    internal abstract fun j(): jet.Tuple0
+    internal open var j1: jet.Int
+    internal open var j: jet.Int
+    internal open var k1: jet.Int
+    internal abstract var k: jet.Int
+    internal open var l1: jet.Int
+    internal abstract var l: jet.Int
+    internal open var n: jet.Int
+}
+// </namespace name="abstract">
@@ -0,0 +1,6 @@
+namespace <root>
+
+internal final class A : jet.Any {
+    public final /*constructor*/ fun <init>(/*0*/ w: jet.Int): A
+    internal final var c: jet.Int
+}
@@ -0,0 +1,13 @@
+namespace <root>
+
+internal final class URI : jet.Any {
+    public final /*constructor*/ fun <init>(/*0*/ body: jet.Any): URI
+    internal final val body: jet.Any
+    internal final fun to(/*0*/ dest: jet.String): jet.Tuple0
+}
+internal final fun bar(/*0*/ f: jet.Function2<jet.Int, jet.Int, jet.Int>): jet.Tuple0
+internal final fun bar1(/*0*/ f: jet.Function1<jet.Int, jet.Int>): jet.Tuple0
+internal final fun bar2(/*0*/ f: jet.Function0<jet.Int>): jet.Tuple0
+internal final fun jet.String.on(/*0*/ predicate: jet.Function1<URI, jet.Boolean>): URI
+internal final fun text(): jet.Tuple0
+internal final fun jet.String.to(/*0*/ dest: jet.String): jet.Tuple0
@@ -0,0 +1,10 @@
+namespace <root>
+
+internal abstract trait B : jet.Any {
+    internal open fun bar(): jet.Tuple0
+}
+internal final class C : jet.Any {
+    public final /*constructor*/ fun <init>(): C
+    internal final fun bar(): jet.Tuple0
+}
+internal final fun test(/*0*/ a: jet.Any?): jet.Tuple0
@@ -0,0 +1,28 @@
+namespace <root>
+
+// <namespace name="example">
+namespace example
+
+// <namespace name="ns">
+namespace ns
+
+internal final val y: jet.Any?
+// </namespace name="ns">
+internal final class example.AClass : jet.Any {
+    public final /*constructor*/ fun <init>(): example.AClass
+    internal final object example.AClass.<no name provided> : jet.Any {
+        internal final /*constructor*/ fun <init>(): example.AClass.<no name provided>
+        internal final val y: jet.Any?
+    }
+}
+internal open class example.C : jet.Any {
+    public final /*constructor*/ fun <init>(): example.C
+    internal final fun foo(): jet.Tuple0
+}
+internal abstract trait example.T : jet.Any {
+}
+internal final val Obj: example.Obj
+internal final val x: jet.Any?
+internal final fun jet.Any?.foo(): jet.Int
+internal final fun jet.Any?.vars(/*0*/ a: jet.Any?): jet.Int
+// </namespace name="example">
@@ -0,0 +1,9 @@
+namespace <root>
+
+internal final class A : jet.Any {
+    public final /*constructor*/ fun <init>(): A
+    internal final val x: jet.Int
+}
+internal final fun foo(/*0*/ u: jet.Tuple0): jet.Int
+internal final fun foo1(): jet.Tuple0
+internal final fun test(): jet.Int
@@ -0,0 +1,12 @@
+namespace <root>
+
+internal final class A : jet.Any {
+    public final /*constructor*/ fun <init>(): A
+}
+internal final class B : jet.Any {
+    public final /*constructor*/ fun <init>(): B
+}
+internal final class C : jet.Any {
+    public final /*constructor*/ fun <init>(): C
+}
+internal final fun f(): jet.Tuple0
@@ -0,0 +1,38 @@
+namespace <root>
+
+// <namespace name="boundsWithSubstitutors">
+namespace boundsWithSubstitutors
+
+internal open class boundsWithSubstitutors.A</*0*/ T : jet.Any?> : jet.Any {
+    public final /*constructor*/ fun </*0*/ T : jet.Any?><init>(): boundsWithSubstitutors.A<T>
+}
+internal final class boundsWithSubstitutors.B</*0*/ X : boundsWithSubstitutors.A<X>> : jet.Any {
+    public final /*constructor*/ fun </*0*/ X : boundsWithSubstitutors.A<X>><init>(): boundsWithSubstitutors.B<X>
+}
+internal final class boundsWithSubstitutors.C : boundsWithSubstitutors.A<boundsWithSubstitutors.C> {
+    public final /*constructor*/ fun <init>(): boundsWithSubstitutors.C
+}
+internal final class boundsWithSubstitutors.X</*0*/ A : jet.Any?, /*1*/ B : A> : jet.Any {
+    public final /*constructor*/ fun </*0*/ A : jet.Any?, /*1*/ B : A><init>(): boundsWithSubstitutors.X<A, B>
+}
+internal final val a: boundsWithSubstitutors.B<boundsWithSubstitutors.C>
+internal final val a1: boundsWithSubstitutors.B<jet.Int>
+internal final val b: boundsWithSubstitutors.X<jet.Any, boundsWithSubstitutors.X<boundsWithSubstitutors.A<boundsWithSubstitutors.C>, boundsWithSubstitutors.C>>
+internal final val b0: boundsWithSubstitutors.X<jet.Any, jet.Any?>
+internal final val b1: boundsWithSubstitutors.X<jet.Any, boundsWithSubstitutors.X<boundsWithSubstitutors.A<boundsWithSubstitutors.C>, jet.String>>
+// </namespace name="boundsWithSubstitutors">
+internal open class A : jet.Any {
+    public final /*constructor*/ fun <init>(): A
+}
+internal open class B</*0*/ T : A> : jet.Any {
+    public final /*constructor*/ fun </*0*/ T : A><init>(): B<T>
+}
+internal abstract class C</*0*/ T : B<jet.Int>, /*1*/ X : jet.Function1<B<jet.Char>, jet.Tuple2<out B<jet.Any>, out B<A>>>> : B<jet.Any> {
+    public final /*constructor*/ fun </*0*/ T : B<jet.Int>, /*1*/ X : jet.Function1<B<jet.Char>, jet.Tuple2<out B<jet.Any>, out B<A>>>><init>(): C<T, X>
+    internal final val a: B<jet.Char>
+    internal abstract val x: jet.Function1<B<jet.Char>, B<jet.Any>>
+}
+internal final fun </*0*/ T : jet.Int?>bar(): jet.Tuple0
+internal final fun </*0*/ T : jet.Int>jet.Int.buzz(): jet.Tuple0
+internal final fun </*0*/ T : jet.Any>foo(): jet.Tuple0
+internal final fun test(): jet.Tuple0
@@ -0,0 +1,13 @@
+namespace <root>
+
+internal final class C : jet.Any {
+    public final /*constructor*/ fun <init>(): C
+    internal final fun containsBreak(/*0*/ a: jet.String?, /*1*/ b: jet.String?): jet.Tuple0
+    internal final fun containsBreakInsideLoopWithLabel(/*0*/ a: jet.String?, /*1*/ array: jet.Array<jet.Int>): jet.Tuple0
+    internal final fun containsBreakToOuterLoop(/*0*/ a: jet.String?, /*1*/ b: jet.String?): jet.Tuple0
+    internal final fun containsBreakWithLabel(/*0*/ a: jet.String?): jet.Tuple0
+    internal final fun containsIllegalBreak(/*0*/ a: jet.String?): jet.Tuple0
+    internal final fun f(/*0*/ a: jet.Boolean, /*1*/ b: jet.Boolean): jet.Tuple0
+    internal final fun notContainsBreak(/*0*/ a: jet.String?, /*1*/ b: jet.String?): jet.Tuple0
+    internal final fun unresolvedBreak(/*0*/ a: jet.String?, /*1*/ array: jet.Array<jet.Int>): jet.Tuple0
+}
@@ -0,0 +1,193 @@
+namespace <root>
+
+// <namespace name="html">
+namespace html
+
+internal final class html.A : html.BodyTag {
+    public final /*constructor*/ fun <init>(): html.A
+    internal final override /*1*/ fun a(/*0*/ href: jet.String, /*1*/ init: jet.ExtensionFunction0<html.A, jet.Tuple0>): jet.Tuple0
+    internal final override /*1*/ val attributes: java.util.HashMap<jet.String, jet.String>
+    internal final override /*1*/ fun b(/*0*/ init: jet.ExtensionFunction0<html.B, jet.Tuple0>): html.B
+    internal final override /*1*/ val children: java.util.ArrayList<html.Element>
+    internal final override /*1*/ fun h1(/*0*/ init: jet.ExtensionFunction0<html.H1, jet.Tuple0>): html.H1
+    public final var href: jet.String?
+    protected final override /*1*/ fun </*0*/ T : html.Element>initTag(/*0*/ tag: T, /*1*/ init: jet.ExtensionFunction0<T, jet.Tuple0>): T
+    invisible_fake final override /*1*/ fun renderAttributes(): jet.String?
+    internal final override /*1*/ fun jet.String.plus(): jet.Tuple0
+    internal final override /*1*/ val name: jet.String
+    internal final override /*1*/ fun p(/*0*/ init: jet.ExtensionFunction0<html.P, jet.Tuple0>): html.P
+    internal open override /*1*/ fun render(/*0*/ builder: java.lang.StringBuilder, /*1*/ indent: jet.String): jet.Tuple0
+    internal final override /*1*/ fun ul(/*0*/ init: jet.ExtensionFunction0<html.UL, jet.Tuple0>): html.UL
+}
+internal final class html.B : html.BodyTag {
+    public final /*constructor*/ fun <init>(): html.B
+    internal final override /*1*/ fun a(/*0*/ href: jet.String, /*1*/ init: jet.ExtensionFunction0<html.A, jet.Tuple0>): jet.Tuple0
+    internal final override /*1*/ val attributes: java.util.HashMap<jet.String, jet.String>
+    internal final override /*1*/ fun b(/*0*/ init: jet.ExtensionFunction0<html.B, jet.Tuple0>): html.B
+    internal final override /*1*/ val children: java.util.ArrayList<html.Element>
+    internal final override /*1*/ fun h1(/*0*/ init: jet.ExtensionFunction0<html.H1, jet.Tuple0>): html.H1
+    protected final override /*1*/ fun </*0*/ T : html.Element>initTag(/*0*/ tag: T, /*1*/ init: jet.ExtensionFunction0<T, jet.Tuple0>): T
+    invisible_fake final override /*1*/ fun renderAttributes(): jet.String?
+    internal final override /*1*/ fun jet.String.plus(): jet.Tuple0
+    internal final override /*1*/ val name: jet.String
+    internal final override /*1*/ fun p(/*0*/ init: jet.ExtensionFunction0<html.P, jet.Tuple0>): html.P
+    internal open override /*1*/ fun render(/*0*/ builder: java.lang.StringBuilder, /*1*/ indent: jet.String): jet.Tuple0
+    internal final override /*1*/ fun ul(/*0*/ init: jet.ExtensionFunction0<html.UL, jet.Tuple0>): html.UL
+}
+internal final class html.Body : html.BodyTag {
+    public final /*constructor*/ fun <init>(): html.Body
+    internal final override /*1*/ fun a(/*0*/ href: jet.String, /*1*/ init: jet.ExtensionFunction0<html.A, jet.Tuple0>): jet.Tuple0
+    internal final override /*1*/ val attributes: java.util.HashMap<jet.String, jet.String>
+    internal final override /*1*/ fun b(/*0*/ init: jet.ExtensionFunction0<html.B, jet.Tuple0>): html.B
+    internal final override /*1*/ val children: java.util.ArrayList<html.Element>
+    internal final override /*1*/ fun h1(/*0*/ init: jet.ExtensionFunction0<html.H1, jet.Tuple0>): html.H1
+    protected final override /*1*/ fun </*0*/ T : html.Element>initTag(/*0*/ tag: T, /*1*/ init: jet.ExtensionFunction0<T, jet.Tuple0>): T
+    invisible_fake final override /*1*/ fun renderAttributes(): jet.String?
+    internal final override /*1*/ fun jet.String.plus(): jet.Tuple0
+    internal final override /*1*/ val name: jet.String
+    internal final override /*1*/ fun p(/*0*/ init: jet.ExtensionFunction0<html.P, jet.Tuple0>): html.P
+    internal open override /*1*/ fun render(/*0*/ builder: java.lang.StringBuilder, /*1*/ indent: jet.String): jet.Tuple0
+    internal final override /*1*/ fun ul(/*0*/ init: jet.ExtensionFunction0<html.UL, jet.Tuple0>): html.UL
+}
+internal abstract class html.BodyTag : html.TagWithText {
+    public final /*constructor*/ fun <init>(/*0*/ name: jet.String): html.BodyTag
+    internal final fun a(/*0*/ href: jet.String, /*1*/ init: jet.ExtensionFunction0<html.A, jet.Tuple0>): jet.Tuple0
+    internal final override /*1*/ val attributes: java.util.HashMap<jet.String, jet.String>
+    internal final fun b(/*0*/ init: jet.ExtensionFunction0<html.B, jet.Tuple0>): html.B
+    internal final override /*1*/ val children: java.util.ArrayList<html.Element>
+    internal final fun h1(/*0*/ init: jet.ExtensionFunction0<html.H1, jet.Tuple0>): html.H1
+    protected final override /*1*/ fun </*0*/ T : html.Element>initTag(/*0*/ tag: T, /*1*/ init: jet.ExtensionFunction0<T, jet.Tuple0>): T
+    invisible_fake final override /*1*/ fun renderAttributes(): jet.String?
+    internal final override /*1*/ fun jet.String.plus(): jet.Tuple0
+    internal final override /*1*/ val name: jet.String
+    internal final fun p(/*0*/ init: jet.ExtensionFunction0<html.P, jet.Tuple0>): html.P
+    internal open override /*1*/ fun render(/*0*/ builder: java.lang.StringBuilder, /*1*/ indent: jet.String): jet.Tuple0
+    internal final fun ul(/*0*/ init: jet.ExtensionFunction0<html.UL, jet.Tuple0>): html.UL
+}
+internal abstract trait html.Element : jet.Any {
+    internal abstract fun render(/*0*/ builder: java.lang.StringBuilder, /*1*/ indent: jet.String): jet.Tuple0
+}
+internal final class html.H1 : html.BodyTag {
+    public final /*constructor*/ fun <init>(): html.H1
+    internal final override /*1*/ fun a(/*0*/ href: jet.String, /*1*/ init: jet.ExtensionFunction0<html.A, jet.Tuple0>): jet.Tuple0
+    internal final override /*1*/ val attributes: java.util.HashMap<jet.String, jet.String>
+    internal final override /*1*/ fun b(/*0*/ init: jet.ExtensionFunction0<html.B, jet.Tuple0>): html.B
+    internal final override /*1*/ val children: java.util.ArrayList<html.Element>
+    internal final override /*1*/ fun h1(/*0*/ init: jet.ExtensionFunction0<html.H1, jet.Tuple0>): html.H1
+    protected final override /*1*/ fun </*0*/ T : html.Element>initTag(/*0*/ tag: T, /*1*/ init: jet.ExtensionFunction0<T, jet.Tuple0>): T
+    invisible_fake final override /*1*/ fun renderAttributes(): jet.String?
+    internal final override /*1*/ fun jet.String.plus(): jet.Tuple0
+    internal final override /*1*/ val name: jet.String
+    internal final override /*1*/ fun p(/*0*/ init: jet.ExtensionFunction0<html.P, jet.Tuple0>): html.P
+    internal open override /*1*/ fun render(/*0*/ builder: java.lang.StringBuilder, /*1*/ indent: jet.String): jet.Tuple0
+    internal final override /*1*/ fun ul(/*0*/ init: jet.ExtensionFunction0<html.UL, jet.Tuple0>): html.UL
+}
+internal final class html.HTML : html.TagWithText {
+    public final /*constructor*/ fun <init>(): html.HTML
+    internal final override /*1*/ val attributes: java.util.HashMap<jet.String, jet.String>
+    internal final fun body(/*0*/ init: jet.ExtensionFunction0<html.Body, jet.Tuple0>): html.Body
+    internal final override /*1*/ val children: java.util.ArrayList<html.Element>
+    internal final fun head(/*0*/ init: jet.ExtensionFunction0<html.Head, jet.Tuple0>): html.Head
+    protected final override /*1*/ fun </*0*/ T : html.Element>initTag(/*0*/ tag: T, /*1*/ init: jet.ExtensionFunction0<T, jet.Tuple0>): T
+    invisible_fake final override /*1*/ fun renderAttributes(): jet.String?
+    internal final override /*1*/ fun jet.String.plus(): jet.Tuple0
+    internal final override /*1*/ val name: jet.String
+    internal open override /*1*/ fun render(/*0*/ builder: java.lang.StringBuilder, /*1*/ indent: jet.String): jet.Tuple0
+}
+internal final class html.Head : html.TagWithText {
+    public final /*constructor*/ fun <init>(): html.Head
+    internal final override /*1*/ val attributes: java.util.HashMap<jet.String, jet.String>
+    internal final override /*1*/ val children: java.util.ArrayList<html.Element>
+    protected final override /*1*/ fun </*0*/ T : html.Element>initTag(/*0*/ tag: T, /*1*/ init: jet.ExtensionFunction0<T, jet.Tuple0>): T
+    invisible_fake final override /*1*/ fun renderAttributes(): jet.String?
+    internal final override /*1*/ fun jet.String.plus(): jet.Tuple0
+    internal final override /*1*/ val name: jet.String
+    internal open override /*1*/ fun render(/*0*/ builder: java.lang.StringBuilder, /*1*/ indent: jet.String): jet.Tuple0
+    internal final fun title(/*0*/ init: jet.ExtensionFunction0<html.Title, jet.Tuple0>): html.Title
+}
+internal final class html.LI : html.BodyTag {
+    public final /*constructor*/ fun <init>(): html.LI
+    internal final override /*1*/ fun a(/*0*/ href: jet.String, /*1*/ init: jet.ExtensionFunction0<html.A, jet.Tuple0>): jet.Tuple0
+    internal final override /*1*/ val attributes: java.util.HashMap<jet.String, jet.String>
+    internal final override /*1*/ fun b(/*0*/ init: jet.ExtensionFunction0<html.B, jet.Tuple0>): html.B
+    internal final override /*1*/ val children: java.util.ArrayList<html.Element>
+    internal final override /*1*/ fun h1(/*0*/ init: jet.ExtensionFunction0<html.H1, jet.Tuple0>): html.H1
+    protected final override /*1*/ fun </*0*/ T : html.Element>initTag(/*0*/ tag: T, /*1*/ init: jet.ExtensionFunction0<T, jet.Tuple0>): T
+    invisible_fake final override /*1*/ fun renderAttributes(): jet.String?
+    internal final override /*1*/ fun jet.String.plus(): jet.Tuple0
+    internal final override /*1*/ val name: jet.String
+    internal final override /*1*/ fun p(/*0*/ init: jet.ExtensionFunction0<html.P, jet.Tuple0>): html.P
+    internal open override /*1*/ fun render(/*0*/ builder: java.lang.StringBuilder, /*1*/ indent: jet.String): jet.Tuple0
+    internal final override /*1*/ fun ul(/*0*/ init: jet.ExtensionFunction0<html.UL, jet.Tuple0>): html.UL
+}
+internal final class html.P : html.BodyTag {
+    public final /*constructor*/ fun <init>(): html.P
+    internal final override /*1*/ fun a(/*0*/ href: jet.String, /*1*/ init: jet.ExtensionFunction0<html.A, jet.Tuple0>): jet.Tuple0
+    internal final override /*1*/ val attributes: java.util.HashMap<jet.String, jet.String>
+    internal final override /*1*/ fun b(/*0*/ init: jet.ExtensionFunction0<html.B, jet.Tuple0>): html.B
+    internal final override /*1*/ val children: java.util.ArrayList<html.Element>
+    internal final override /*1*/ fun h1(/*0*/ init: jet.ExtensionFunction0<html.H1, jet.Tuple0>): html.H1
+    protected final override /*1*/ fun </*0*/ T : html.Element>initTag(/*0*/ tag: T, /*1*/ init: jet.ExtensionFunction0<T, jet.Tuple0>): T
+    invisible_fake final override /*1*/ fun renderAttributes(): jet.String?
+    internal final override /*1*/ fun jet.String.plus(): jet.Tuple0
+    internal final override /*1*/ val name: jet.String
+    internal final override /*1*/ fun p(/*0*/ init: jet.ExtensionFunction0<html.P, jet.Tuple0>): html.P
+    internal open override /*1*/ fun render(/*0*/ builder: java.lang.StringBuilder, /*1*/ indent: jet.String): jet.Tuple0
+    internal final override /*1*/ fun ul(/*0*/ init: jet.ExtensionFunction0<html.UL, jet.Tuple0>): html.UL
+}
+internal abstract class html.Tag : html.Element {
+    public final /*constructor*/ fun <init>(/*0*/ name: jet.String): html.Tag
+    internal final val attributes: java.util.HashMap<jet.String, jet.String>
+    internal final val children: java.util.ArrayList<html.Element>
+    protected final fun </*0*/ T : html.Element>initTag(/*0*/ tag: T, /*1*/ init: jet.ExtensionFunction0<T, jet.Tuple0>): T
+    internal final val name: jet.String
+    internal open override /*1*/ fun render(/*0*/ builder: java.lang.StringBuilder, /*1*/ indent: jet.String): jet.Tuple0
+    private final fun renderAttributes(): jet.String?
+}
+internal abstract class html.TagWithText : html.Tag {
+    public final /*constructor*/ fun <init>(/*0*/ name: jet.String): html.TagWithText
+    internal final override /*1*/ val attributes: java.util.HashMap<jet.String, jet.String>
+    internal final override /*1*/ val children: java.util.ArrayList<html.Element>
+    protected final override /*1*/ fun </*0*/ T : html.Element>initTag(/*0*/ tag: T, /*1*/ init: jet.ExtensionFunction0<T, jet.Tuple0>): T
+    invisible_fake final override /*1*/ fun renderAttributes(): jet.String?
+    internal final fun jet.String.plus(): jet.Tuple0
+    internal final override /*1*/ val name: jet.String
+    internal open override /*1*/ fun render(/*0*/ builder: java.lang.StringBuilder, /*1*/ indent: jet.String): jet.Tuple0
+}
+internal final class html.TextElement : html.Element {
+    public final /*constructor*/ fun <init>(/*0*/ text: jet.String): html.TextElement
+    internal open override /*1*/ fun render(/*0*/ builder: java.lang.StringBuilder, /*1*/ indent: jet.String): jet.Tuple0
+    internal final val text: jet.String
+}
+internal final class html.Title : html.TagWithText {
+    public final /*constructor*/ fun <init>(): html.Title
+    internal final override /*1*/ val attributes: java.util.HashMap<jet.String, jet.String>
+    internal final override /*1*/ val children: java.util.ArrayList<html.Element>
+    protected final override /*1*/ fun </*0*/ T : html.Element>initTag(/*0*/ tag: T, /*1*/ init: jet.ExtensionFunction0<T, jet.Tuple0>): T
+    invisible_fake final override /*1*/ fun renderAttributes(): jet.String?
+    internal final override /*1*/ fun jet.String.plus(): jet.Tuple0
+    internal final override /*1*/ val name: jet.String
+    internal open override /*1*/ fun render(/*0*/ builder: java.lang.StringBuilder, /*1*/ indent: jet.String): jet.Tuple0
+}
+internal final class html.UL : html.BodyTag {
+    public final /*constructor*/ fun <init>(): html.UL
+    internal final override /*1*/ fun a(/*0*/ href: jet.String, /*1*/ init: jet.ExtensionFunction0<html.A, jet.Tuple0>): jet.Tuple0
+    internal final override /*1*/ val attributes: java.util.HashMap<jet.String, jet.String>
+    internal final override /*1*/ fun b(/*0*/ init: jet.ExtensionFunction0<html.B, jet.Tuple0>): html.B
+    internal final override /*1*/ val children: java.util.ArrayList<html.Element>
+    internal final override /*1*/ fun h1(/*0*/ init: jet.ExtensionFunction0<html.H1, jet.Tuple0>): html.H1
+    protected final override /*1*/ fun </*0*/ T : html.Element>initTag(/*0*/ tag: T, /*1*/ init: jet.ExtensionFunction0<T, jet.Tuple0>): T
+    invisible_fake final override /*1*/ fun renderAttributes(): jet.String?
+    internal final override /*1*/ fun jet.String.plus(): jet.Tuple0
+    internal final fun li(/*0*/ init: jet.ExtensionFunction0<html.LI, jet.Tuple0>): html.LI
+    internal final override /*1*/ val name: jet.String
+    internal final override /*1*/ fun p(/*0*/ init: jet.ExtensionFunction0<html.P, jet.Tuple0>): html.P
+    internal open override /*1*/ fun render(/*0*/ builder: java.lang.StringBuilder, /*1*/ indent: jet.String): jet.Tuple0
+    internal final override /*1*/ fun ul(/*0*/ init: jet.ExtensionFunction0<html.UL, jet.Tuple0>): html.UL
+}
+internal final fun html(/*0*/ init: jet.ExtensionFunction0<html.HTML, jet.Tuple0>): html.HTML
+internal final fun main(/*0*/ args: jet.Array<jet.String>): jet.Tuple0
+internal final fun print(/*0*/ message: jet.Any?): jet.Tuple0
+internal final fun println(/*0*/ message: jet.Any?): jet.Tuple0
+internal final fun </*0*/ K : jet.Any?, /*1*/ V : jet.Any?>java.util.Map<K, V>.set(/*0*/ key: K, /*1*/ value: V): V?
+// </namespace name="html">
@@ -0,0 +1,3 @@
+namespace <root>
+
+internal final fun test(): jet.Tuple0
@@ -0,0 +1,3 @@
+namespace <root>
+
+internal final fun test(/*0*/ c: jet.Char): jet.Tuple0
@@ -0,0 +1,10 @@
+namespace <root>
+
+internal final class A : jet.Any {
+    public final /*constructor*/ fun <init>(): A
+    internal final val x: jet.Int
+    internal final object A.<no name provided> : jet.Any {
+        internal final /*constructor*/ fun <init>(): A.<no name provided>
+        internal final val y: [ERROR : Type for x]
+    }
+}
@@ -0,0 +1,23 @@
+namespace <root>
+
+// <namespace name="Jet86">
+namespace Jet86
+
+internal final class Jet86.A : jet.Any {
+    public final /*constructor*/ fun <init>(): Jet86.A
+    internal final object Jet86.A.<no name provided> : jet.Any {
+        internal final /*constructor*/ fun <init>(): Jet86.A.<no name provided>
+        internal final val x: jet.Int
+    }
+}
+internal final class Jet86.B : jet.Any {
+    public final /*constructor*/ fun <init>(): Jet86.B
+    internal final val x: jet.Int
+}
+internal final val a: jet.Int
+internal final val b: Jet86.b
+internal final val c: jet.Int
+internal final val d: [ERROR : Type for b.x]
+internal final val s: java.lang.System
+internal final fun test(): jet.Tuple0
+// </namespace name="Jet86">
@@ -0,0 +1,3 @@
+namespace <root>
+
+internal final fun test(): jet.Tuple0
@@ -0,0 +1,23 @@
+namespace <root>
+
+internal abstract trait A : jet.Any {
+    internal abstract val a1: jet.Int
+    internal abstract val a: jet.Int
+    internal open fun foo(): jet.Int
+    internal open fun foo1(): jet.Int
+    internal open fun foo2(): jet.Int
+    internal abstract fun </*0*/ T : jet.Any?>g(): T
+    internal abstract fun </*0*/ T : jet.Any?>g1(): T
+    internal abstract val  </*0*/ T : jet.Any?> g: jet.Iterator<T>
+}
+internal abstract class B : A {
+    public final /*constructor*/ fun <init>(): B
+    internal open override /*1*/ val a1: jet.Double
+    internal open override /*1*/ val a: jet.Double
+    internal open override /*1*/ fun foo(): jet.Tuple0
+    internal open override /*1*/ fun foo1(): jet.Int
+    internal open override /*1*/ fun foo2(): jet.Tuple0
+    internal abstract override /*1*/ fun </*0*/ X : jet.Any?>g(): jet.Int
+    internal abstract override /*1*/ fun </*0*/ X : jet.Any?>g1(): java.util.List<X>
+    internal abstract override /*1*/ val  </*0*/ X : jet.Any?> g: jet.Iterator<jet.Int>
+}
@@ -0,0 +1,18 @@
+namespace <root>
+
+internal final class Foo : jet.Any {
+    public final /*constructor*/ fun <init>(): Foo
+    private final val builder: java.lang.StringBuilder
+}
+internal final class Foo1 : jet.Any {
+    public final /*constructor*/ fun <init>(): Foo1
+    private final val builder: [ERROR : Type for StringBuilder("sdfsd")
+    
+            {
+            }]
+}
+internal final fun foo(): jet.Function0<[ERROR : <return type>]>
+internal final fun foo1(): jet.Function0<jet.Function0<jet.Tuple0>>
+internal final fun println(): jet.Tuple0
+internal final fun println(/*0*/ i: jet.Int): jet.Tuple0
+internal final fun println(/*0*/ s: jet.Byte): jet.Tuple0
@@ -0,0 +1,5 @@
+namespace <root>
+
+internal abstract trait T : jet.Any {
+    internal open val a: [ERROR : <ERROR FUNCTION RETURN TYPE>]
+}
@@ -0,0 +1,17 @@
+namespace <root>
+
+internal open class Base : jet.Any {
+    public final /*constructor*/ fun <init>(): Base
+    internal final fun f(): jet.Int
+}
+internal final class Diamond : Left, Right {
+    public final /*constructor*/ fun <init>(): Diamond
+    internal final override /*2*/ fun f(): jet.Int
+}
+internal open class Left : Base {
+    public final /*constructor*/ fun <init>(): Left
+    internal final override /*1*/ fun f(): jet.Int
+}
+internal abstract trait Right : Base {
+    internal final override /*1*/ fun f(): jet.Int
+}
@@ -0,0 +1,17 @@
+namespace <root>
+
+internal open class Base</*0*/ P : jet.Any?> : jet.Any {
+    public final /*constructor*/ fun </*0*/ P : jet.Any?><init>(): Base<P>
+    internal final fun f(): jet.Int
+}
+internal final class Diamond</*0*/ P : jet.Any?> : Left<P>, Right<P> {
+    public final /*constructor*/ fun </*0*/ P : jet.Any?><init>(): Diamond<P>
+    internal final override /*2*/ fun f(): jet.Int
+}
+internal open class Left</*0*/ P : jet.Any?> : Base<P> {
+    public final /*constructor*/ fun </*0*/ P : jet.Any?><init>(): Left<P>
+    internal final override /*1*/ fun f(): jet.Int
+}
+internal abstract trait Right</*0*/ P : jet.Any?> : Base<P> {
+    internal final override /*1*/ fun f(): jet.Int
+}
@@ -0,0 +1,17 @@
+namespace <root>
+
+internal open class Base : jet.Any {
+    public final /*constructor*/ fun <init>(): Base
+    internal final var v: jet.Int
+}
+internal final class Diamond : Left, Right {
+    public final /*constructor*/ fun <init>(): Diamond
+    internal final override /*2*/ var v: jet.Int
+}
+internal open class Left : Base {
+    public final /*constructor*/ fun <init>(): Left
+    internal final override /*1*/ var v: jet.Int
+}
+internal abstract trait Right : Base {
+    internal final override /*1*/ var v: jet.Int
+}
@@ -0,0 +1,17 @@
+namespace <root>
+
+// <namespace name="dollar">
+namespace dollar
+
+internal open class dollar.$ : jet.Any {
+    public final /*constructor*/ fun <init>(): dollar.$
+}
+internal open class dollar.$$ : dollar.$ {
+    public open fun $$$$$$(): dollar.$$$$$?
+    internal final val $$$: dollar.$$$$$?
+    public final /*constructor*/ fun <init>(/*0*/ $$$$: dollar.$$$$$?): dollar.$$
+}
+internal open class dollar.$$$$$ : jet.Any {
+    public final /*constructor*/ fun <init>(): dollar.$$$$$
+}
+// </namespace name="dollar">
@@ -0,0 +1,76 @@
+namespace <root>
+
+internal abstract class AmbiguousHasNextIterator : jet.Any {
+    public final /*constructor*/ fun <init>(): AmbiguousHasNextIterator
+    internal abstract fun hasNext(): jet.Boolean
+    internal final val hasNext: jet.Boolean
+    internal abstract fun next(): jet.Int
+}
+internal abstract class GoodIterator : jet.Any {
+    public final /*constructor*/ fun <init>(): GoodIterator
+    internal abstract fun hasNext(): jet.Boolean
+    internal abstract fun next(): jet.Int
+}
+internal abstract class ImproperIterator1 : jet.Any {
+    public final /*constructor*/ fun <init>(): ImproperIterator1
+    internal abstract fun hasNext(): jet.Boolean
+}
+internal abstract class ImproperIterator2 : jet.Any {
+    public final /*constructor*/ fun <init>(): ImproperIterator2
+    internal abstract fun next(): jet.Boolean
+}
+internal abstract class ImproperIterator3 : jet.Any {
+    public final /*constructor*/ fun <init>(): ImproperIterator3
+    internal abstract fun hasNext(): jet.Int
+    internal abstract fun next(): jet.Int
+}
+internal abstract class ImproperIterator4 : jet.Any {
+    public final /*constructor*/ fun <init>(): ImproperIterator4
+    internal final val hasNext: jet.Int
+    internal abstract fun next(): jet.Int
+}
+internal abstract class ImproperIterator5 : jet.Any {
+    public final /*constructor*/ fun <init>(): ImproperIterator5
+    internal abstract val jet.String.hasNext: jet.Boolean
+    internal abstract fun next(): jet.Int
+}
+internal final class NotRange1 : jet.Any {
+    public final /*constructor*/ fun <init>(): NotRange1
+}
+internal abstract class NotRange2 : jet.Any {
+    public final /*constructor*/ fun <init>(): NotRange2
+    internal abstract fun iterator(): jet.Tuple0
+}
+internal abstract class NotRange3 : jet.Any {
+    public final /*constructor*/ fun <init>(): NotRange3
+    internal abstract fun iterator(): ImproperIterator1
+}
+internal abstract class NotRange4 : jet.Any {
+    public final /*constructor*/ fun <init>(): NotRange4
+    internal abstract fun iterator(): ImproperIterator2
+}
+internal abstract class NotRange5 : jet.Any {
+    public final /*constructor*/ fun <init>(): NotRange5
+    internal abstract fun iterator(): ImproperIterator3
+}
+internal abstract class NotRange6 : jet.Any {
+    public final /*constructor*/ fun <init>(): NotRange6
+    internal abstract fun iterator(): AmbiguousHasNextIterator
+}
+internal abstract class NotRange7 : jet.Any {
+    public final /*constructor*/ fun <init>(): NotRange7
+    internal abstract fun iterator(): ImproperIterator3
+}
+internal abstract class NotRange8 : jet.Any {
+    public final /*constructor*/ fun <init>(): NotRange8
+    internal abstract fun iterator(): ImproperIterator5
+}
+internal abstract class Range0 : jet.Any {
+    public final /*constructor*/ fun <init>(): Range0
+    internal abstract fun iterator(): GoodIterator
+}
+internal abstract class Range1 : jet.Any {
+    public final /*constructor*/ fun <init>(): Range1
+    internal abstract fun iterator(): java.util.Iterator<jet.Int>
+}
+internal final fun test(/*0*/ notRange1: NotRange1, /*1*/ notRange2: NotRange2, /*2*/ notRange3: NotRange3, /*3*/ notRange4: NotRange4, /*4*/ notRange5: NotRange5, /*5*/ notRange6: NotRange6, /*6*/ notRange7: NotRange7, /*7*/ notRange8: NotRange8, /*8*/ range0: Range0, /*9*/ range1: Range1): jet.Tuple0
@@ -0,0 +1,15 @@
+namespace <root>
+
+// <namespace name="foo">
+namespace foo
+
+internal final fun f(): jet.ExtensionFunction0<jet.Int, jet.Tuple0>
+internal final fun jet.Any.foo(): jet.Function0<jet.Tuple0>
+internal final fun jet.Any.foo1(): jet.Function1<jet.Int, jet.Tuple0>
+internal final fun foo2(): jet.Function1<jet.Function0<jet.Tuple0>, jet.Tuple0>
+internal final fun </*0*/ T : jet.Any?>fooT1(/*0*/ t: T): jet.Function0<T>
+internal final fun </*0*/ T : jet.Any?>fooT2(): jet.Function1<T, T>
+internal final fun main(/*0*/ args: jet.Array<jet.String>): jet.Tuple0
+internal final fun main1(): jet.Tuple0
+internal final fun test(): jet.Tuple0
+// </namespace name="foo">
@@ -0,0 +1,72 @@
+namespace <root>
+
+// <namespace name="x">
+namespace x
+
+internal abstract trait x.AA1</*0*/ out T : jet.Any?> : jet.Any {
+}
+internal abstract trait x.AB1 : x.AA1<jet.Int> {
+}
+internal abstract trait x.AB2 : x.AA1<jet.Number>, x.AB1, x.AB3 {
+}
+internal abstract trait x.AB3 : x.AA1<jet.Comparable<jet.Int>> {
+}
+// </namespace name="x">
+// <namespace name="x2">
+namespace x2
+
+internal abstract trait x2.AA1</*0*/ out T : jet.Any?> : jet.Any {
+}
+internal abstract trait x2.AB1 : x2.AA1<jet.Any> {
+}
+internal abstract trait x2.AB2 : x2.AA1<jet.Number>, x2.AB1, x2.AB3 {
+}
+internal abstract trait x2.AB3 : x2.AA1<jet.Comparable<jet.Int>> {
+}
+// </namespace name="x2">
+// <namespace name="x3">
+namespace x3
+
+internal abstract trait x3.AA1</*0*/ in T : jet.Any?> : jet.Any {
+}
+internal abstract trait x3.AB1 : x3.AA1<jet.Any> {
+}
+internal abstract trait x3.AB2 : x3.AA1<jet.Number>, x3.AB1, x3.AB3 {
+}
+internal abstract trait x3.AB3 : x3.AA1<jet.Comparable<jet.Int>> {
+}
+// </namespace name="x3">
+// <namespace name="sx2">
+namespace sx2
+
+internal abstract trait sx2.AA1</*0*/ in T : jet.Any?> : jet.Any {
+}
+internal abstract trait sx2.AB1 : sx2.AA1<jet.Int> {
+}
+internal abstract trait sx2.AB2 : sx2.AA1<jet.Number>, sx2.AB1, sx2.AB3 {
+}
+internal abstract trait sx2.AB3 : sx2.AA1<jet.Comparable<jet.Int>> {
+}
+// </namespace name="sx2">
+internal abstract trait A</*0*/ in T : jet.Any?> : jet.Any {
+}
+internal abstract trait A1</*0*/ out T : jet.Any?> : jet.Any {
+}
+internal abstract trait B</*0*/ T : jet.Any?> : A<jet.Int> {
+}
+internal abstract trait B1 : A1<jet.Int> {
+}
+internal abstract trait B2 : A1<jet.Any>, B1 {
+}
+internal abstract trait BA1</*0*/ T : jet.Any?> : jet.Any {
+}
+internal abstract trait BB1 : BA1<jet.Int> {
+}
+internal abstract trait BB2 : BA1<jet.Any>, BB1 {
+}
+internal abstract trait C</*0*/ T : jet.Any?> : B<T>, A<T> {
+}
+internal abstract trait C1</*0*/ T : jet.Any?> : B<T>, A<jet.Any> {
+}
+internal abstract trait D : C<jet.Boolean>, B<jet.Double> {
+}
@@ -0,0 +1,5 @@
+namespace <root>
+
+internal final fun foo(/*0*/ i: jet.Int): jet.Int
+internal final fun </*0*/ T : jet.Any?>foo(/*0*/ t: T): jet.Tuple0
+internal final fun test(): jet.Tuple0
@@ -0,0 +1,21 @@
+namespace <root>
+
+// <namespace name="illegal_modifiers">
+namespace illegal_modifiers
+
+internal abstract class illegal_modifiers.A : jet.Any {
+    public final /*constructor*/ fun <init>(): illegal_modifiers.A
+    internal abstract fun f(): jet.Tuple0
+    internal abstract fun g(): jet.Tuple0
+    internal open fun h(): jet.Tuple0
+    internal open var r: jet.String protected set
+}
+internal final class illegal_modifiers.FinalClass : jet.Any {
+    public final /*constructor*/ fun <init>(): illegal_modifiers.FinalClass
+    internal open fun foo(): jet.Tuple0
+    internal final val i: jet.Int
+    internal final var j: jet.Int
+}
+internal final trait illegal_modifiers.T : jet.Any {
+}
+// </namespace name="illegal_modifiers">
@@ -0,0 +1,26 @@
+namespace <root>
+
+// <namespace name="a">
+namespace a
+
+internal final val x: b.X
+// </namespace name="a">
+// <namespace name="b">
+namespace b
+
+internal final class b.X : jet.Any {
+    public final /*constructor*/ fun <init>(): b.X
+}
+// </namespace name="b">
+// <namespace name="c">
+namespace c
+
+internal final val x: d.X
+// </namespace name="c">
+// <namespace name="d">
+namespace d
+
+internal final class d.X : jet.Any {
+    public final /*constructor*/ fun <init>(): d.X
+}
+// </namespace name="d">
@@ -0,0 +1,20 @@
+namespace <root>
+
+internal final class IncDec : jet.Any {
+    public final /*constructor*/ fun <init>(): IncDec
+    internal final fun dec(): IncDec
+    internal final fun inc(): IncDec
+}
+internal final class UnitIncDec : jet.Any {
+    public final /*constructor*/ fun <init>(): UnitIncDec
+    internal final fun dec(): jet.Tuple0
+    internal final fun inc(): jet.Tuple0
+}
+internal final class WrongIncDec : jet.Any {
+    public final /*constructor*/ fun <init>(): WrongIncDec
+    internal final fun dec(): jet.Int
+    internal final fun inc(): jet.Int
+}
+internal final fun testIncDec(): jet.Tuple0
+internal final fun testUnitIncDec(): jet.Tuple0
+internal final fun testWrongIncDec(): jet.Tuple0
@@ -0,0 +1,4 @@
+namespace <root>
+
+internal final fun ff(): jet.Tuple0
+internal final fun test(): jet.Tuple0
@@ -0,0 +1,4 @@
+namespace <root>
+
+internal final fun ff(/*0*/ a: jet.String): jet.Int
+internal final fun gg(): jet.Tuple0
@@ -0,0 +1,3 @@
+namespace <root>
+
+internal final fun test(): jet.Tuple0
@@ -0,0 +1,47 @@
+namespace <root>
+
+// <namespace name="lvalue_assignment">
+namespace lvalue_assignment
+
+internal final class lvalue_assignment.A : jet.Any {
+    public final /*constructor*/ fun <init>(): lvalue_assignment.A
+    internal final var a: jet.Int
+}
+internal abstract class lvalue_assignment.Ab : jet.Any {
+    public final /*constructor*/ fun <init>(): lvalue_assignment.Ab
+    internal abstract fun getArray(): jet.Array<jet.Int>
+}
+internal open class lvalue_assignment.B : jet.Any {
+    public final /*constructor*/ fun <init>(): lvalue_assignment.B
+    internal final var b: jet.Int
+    internal final val c: jet.Int
+}
+internal final class lvalue_assignment.C : lvalue_assignment.B {
+    public final /*constructor*/ fun <init>(): lvalue_assignment.C
+    internal final override /*1*/ var b: jet.Int
+    internal final fun bar(/*0*/ c: lvalue_assignment.C): jet.Tuple0
+    internal final override /*1*/ val c: jet.Int
+    internal final fun foo(/*0*/ c: lvalue_assignment.C): jet.Tuple0
+    internal final fun foo1(/*0*/ c: lvalue_assignment.C): jet.Tuple0
+    internal final var x: jet.Int
+}
+internal final class lvalue_assignment.D : jet.Any {
+    public final /*constructor*/ fun <init>(): lvalue_assignment.D
+    internal final class lvalue_assignment.D.B : jet.Any {
+        public final /*constructor*/ fun <init>(): lvalue_assignment.D.B
+        internal final fun foo(): jet.Tuple0
+    }
+}
+internal final class lvalue_assignment.Test : jet.Any {
+    public final /*constructor*/ fun <init>(): lvalue_assignment.Test
+    internal final fun testArrays(/*0*/ a: jet.Array<jet.Int>, /*1*/ ab: lvalue_assignment.Ab): jet.Tuple0
+    internal final fun testIllegalValues(): jet.Tuple0
+    internal final fun testVariables(): jet.Tuple0
+    internal final fun testVariables1(): jet.Tuple0
+}
+internal final fun canBe(/*0*/ i: jet.Int, /*1*/ j: jet.Int): jet.Tuple0
+internal final fun canBe2(/*0*/ j: jet.Int): jet.Tuple0
+internal final fun cannotBe(/*0*/ i: jet.Int): jet.Tuple0
+internal final fun jet.Array<jet.Int>.checkThis(): jet.Tuple0
+internal final fun getInt(): jet.Int
+// </namespace name="lvalue_assignment">
@@ -0,0 +1,8 @@
+namespace <root>
+
+// <namespace name="java">
+namespace java
+
+internal final val c: java.lang.Class<out jet.Any?>?
+internal final val  </*0*/ T : jet.Any?> jet.Array<T>?.length: jet.Int
+// </namespace name="java">
@@ -0,0 +1,4 @@
+namespace <root>
+
+internal final fun box(): jet.String
+internal final fun new(): jet.String
@@ -0,0 +1,54 @@
+namespace <root>
+
+// <namespace name="Jet87">
+namespace Jet87
+
+internal open class Jet87.A : jet.Any {
+    public final /*constructor*/ fun <init>(): Jet87.A
+    internal final fun foo(): jet.Int
+}
+internal abstract trait Jet87.B : jet.Any {
+    internal open fun bar(): jet.Double
+}
+internal final class Jet87.Bar</*0*/ T : Jet87.Foo> : jet.Any {
+    public final /*constructor*/ fun </*0*/ T : Jet87.Foo><init>(): Jet87.Bar<T>
+}
+internal final class Jet87.Buzz</*0*/ T : Jet87.Bar<jet.Int> & [ERROR : nioho]> : jet.Any {
+    public final /*constructor*/ fun </*0*/ T : Jet87.Bar<jet.Int> & [ERROR : nioho]><init>(): Jet87.Buzz<T>
+}
+internal final class Jet87.C : Jet87.A, Jet87.B {
+    public final /*constructor*/ fun <init>(): Jet87.C
+    internal open override /*1*/ fun bar(): jet.Double
+    internal final override /*1*/ fun foo(): jet.Int
+}
+internal final class Jet87.D : jet.Any {
+    public final /*constructor*/ fun <init>(): Jet87.D
+    internal final object Jet87.D.<no name provided> : Jet87.A, Jet87.B {
+        internal final /*constructor*/ fun <init>(): Jet87.D.<no name provided>
+        internal open override /*1*/ fun bar(): jet.Double
+        internal final override /*1*/ fun foo(): jet.Int
+    }
+}
+internal final class Jet87.Foo : jet.Any {
+    public final /*constructor*/ fun <init>(): Jet87.Foo
+}
+internal final class Jet87.Test</*0*/ T : jet.Any?> : jet.Any {
+    public final /*constructor*/ fun </*0*/ T : jet.Any?><init>(): Jet87.Test<T>
+}
+internal final class Jet87.Test1</*0*/ T : Jet87.A & Jet87.B> : jet.Any {
+    public final /*constructor*/ fun </*0*/ T : Jet87.A & Jet87.B><init>(): Jet87.Test1<T>
+    internal final fun test(/*0*/ t: T): jet.Tuple0
+}
+internal final class Jet87.X</*0*/ T : Jet87.Foo> : jet.Any {
+    public final /*constructor*/ fun </*0*/ T : Jet87.Foo><init>(): Jet87.X<T>
+}
+internal final class Jet87.Y</*0*/ T : Jet87.Bar<Jet87.Foo> & Jet87.Foo> : jet.Any {
+    public final /*constructor*/ fun </*0*/ T : Jet87.Bar<Jet87.Foo> & Jet87.Foo><init>(): Jet87.Y<T>
+}
+internal final val t1: jet.Tuple0
+internal final val t2: jet.Tuple0
+internal final val t3: jet.Tuple0
+internal final val  </*0*/ T : jet.Any?, /*1*/ B : T> x: jet.Int
+internal final fun test(): jet.Tuple0
+internal final fun </*0*/ T : Jet87.A & Jet87.B>test2(/*0*/ t: T): jet.Tuple0
+// </namespace name="Jet87">
@@ -0,0 +1,5 @@
+namespace <root>
+
+internal final fun bar(/*0*/ x: jet.Int = ?, /*1*/ y: jet.Int = ?, /*2*/ z: jet.String): jet.Tuple0
+internal final fun foo(/*0*/ a: jet.Int = ?, /*1*/ b: jet.String = ?): jet.Tuple0
+internal final fun test(): jet.Tuple0
@@ -0,0 +1,16 @@
+namespace <root>
+
+// <namespace name="foo">
+namespace foo
+
+internal final class foo.X : jet.Any {
+    public final /*constructor*/ fun <init>(): foo.X
+}
+internal final val s: [ERROR : Type for java]
+internal final val ss: java.lang.System
+internal final val sss: foo.X
+internal final val xs: [ERROR : Type for lang]
+internal final val xss: java.lang.System
+internal final val xsss: foo.X
+internal final val xssss: [ERROR : Type for foo]
+// </namespace name="foo">
@@ -0,0 +1,48 @@
+namespace <root>
+
+// <namespace name="foobar">
+namespace foobar
+
+// <namespace name="a">
+namespace a
+
+internal final val a: java.util.List<jet.Int>?
+internal final val a1: [ERROR : List<Int>]
+internal final val b: java.util.List<jet.Int>?
+internal final val b1: [ERROR : util.List<Int>]
+// </namespace name="a">
+internal abstract class foobar.Collection</*0*/ E : jet.Any?> : jet.Iterable<E> {
+    public final /*constructor*/ fun </*0*/ E : jet.Any?><init>(): foobar.Collection<E>
+    internal final fun </*0*/ O : jet.Any?>iterate(/*0*/ iteratee: foobar.Iteratee<E, O>): O
+    public abstract override /*1*/ fun iterator(): jet.Iterator<E>
+}
+internal abstract class foobar.Foo</*0*/ T : jet.Any?> : jet.Any {
+    public final /*constructor*/ fun </*0*/ T : jet.Any?><init>(): foobar.Foo<T>
+    internal abstract val x: T
+}
+internal abstract class foobar.Iteratee</*0*/ in I : jet.Any?, /*1*/ out O : jet.Any?> : jet.Any {
+    public final /*constructor*/ fun </*0*/ in I : jet.Any?, /*1*/ out O : jet.Any?><init>(): foobar.Iteratee<I, O>
+    internal abstract fun done(): O
+    internal abstract val isDone: jet.Boolean
+    internal abstract fun process(/*0*/ item: I): foobar.Iteratee<I, O>
+    internal abstract val result: O
+}
+internal final class foobar.StrangeIterateeImpl</*0*/ in I : jet.Any?, /*1*/ out O : jet.Any?> : foobar.Iteratee<I, O> {
+    public final /*constructor*/ fun </*0*/ in I : jet.Any?, /*1*/ out O : jet.Any?><init>(/*0*/ obj: O): foobar.StrangeIterateeImpl<I, O>
+    internal open override /*1*/ fun done(): O
+    internal open override /*1*/ val isDone: jet.Boolean
+    internal final val obj: O
+    internal open override /*1*/ fun process(/*0*/ item: I): foobar.Iteratee<I, O>
+    internal open override /*1*/ val result: O
+}
+internal abstract class foobar.Sum : foobar.Iteratee<jet.Int, jet.Int> {
+    public final /*constructor*/ fun <init>(): foobar.Sum
+    internal abstract override /*1*/ fun done(): jet.Int
+    internal abstract override /*1*/ val isDone: jet.Boolean
+    internal open override /*1*/ fun process(/*0*/ item: jet.Int): foobar.Iteratee<jet.Int, jet.Int>
+    internal abstract override /*1*/ val result: jet.Int
+}
+internal final val x1: java.util.List<jet.Int>?
+internal final val y1: java.util.List<jet.Int>?
+internal final fun </*0*/ O : jet.Any?>done(/*0*/ result: O): foobar.Iteratee<jet.Any?, O>
+// </namespace name="foobar">
@@ -0,0 +1,13 @@
+namespace <root>
+
+internal final fun f(/*0*/ out: jet.String?): jet.Tuple0
+internal final fun f1(/*0*/ out: jet.String?): jet.Tuple0
+internal final fun f2(/*0*/ out: jet.String?): jet.Tuple0
+internal final fun f3(/*0*/ out: jet.String?): jet.Tuple0
+internal final fun f4(/*0*/ s: jet.String?): jet.Tuple0
+internal final fun f5(/*0*/ s: jet.String?): jet.Tuple0
+internal final fun f6(/*0*/ s: jet.String?): jet.Tuple0
+internal final fun f7(/*0*/ s: jet.String?, /*1*/ t: jet.String?): jet.Tuple0
+internal final fun f8(/*0*/ b: jet.String?, /*1*/ a: jet.String): jet.Tuple0
+internal final fun f9(/*0*/ a: jet.Int?): jet.Int
+internal final fun test(): jet.Tuple0
@@ -0,0 +1,11 @@
+namespace <root>
+
+internal abstract class B : jet.Any {
+    public final /*constructor*/ fun <init>(): B
+    internal abstract fun foo2(/*0*/ arg: jet.Int = ?): jet.Int
+}
+internal final class C : B {
+    public final /*constructor*/ fun <init>(): C
+    internal open override /*1*/ fun foo2(/*0*/ arg: jet.Int = ?): jet.Int
+}
+internal final fun invokeIt(): jet.Tuple0
@@ -0,0 +1,10 @@
+namespace <root>
+
+internal abstract trait Aaa</*0*/ T : jet.Any?> : jet.Any {
+    internal abstract fun zzz(/*0*/ value: T): jet.Tuple0
+}
+internal final class Bbb</*0*/ T : jet.Any?> : Aaa<T> {
+    public final /*constructor*/ fun </*0*/ T : jet.Any?><init>(): Bbb<T>
+    internal open override /*1*/ fun zzz(/*0*/ value: T): jet.Tuple0
+}
+internal final fun foo(): jet.Tuple0
@@ -0,0 +1,17 @@
+namespace <root>
+
+internal final class Val : Var, VarT {
+    public final /*constructor*/ fun <init>(): Val
+    internal open override /*2*/ val v: jet.Int
+}
+internal open class Var : jet.Any {
+    public final /*constructor*/ fun <init>(): Var
+    internal open var v: jet.Int
+}
+internal final class Var2 : Var {
+    public final /*constructor*/ fun <init>(): Var2
+    internal open override /*1*/ var v: jet.Int
+}
+internal abstract trait VarT : jet.Any {
+    internal abstract var v: jet.Int
+}
@@ -0,0 +1,27 @@
+namespace <root>
+
+internal final class MyIterable</*0*/ T : jet.Any?> : jet.Iterable<T> {
+    public final /*constructor*/ fun </*0*/ T : jet.Any?><init>(): MyIterable<T>
+    internal final class MyIterable.MyIterator : jet.Iterator<T> {
+        public final /*constructor*/ fun <init>(): MyIterable.MyIterator
+        public open override /*1*/ val hasNext: jet.Boolean
+        public open override /*1*/ fun next(): T
+    }
+    public open override /*1*/ fun iterator(): jet.Iterator<T>
+}
+internal final class X : jet.Any {
+    public final /*constructor*/ fun <init>(): X
+    internal final val x: jet.Int
+}
+internal open class Y : jet.Any {
+    public final /*constructor*/ fun <init>(): Y
+    internal final val x: jet.Int
+}
+internal final class Y1 : jet.Any {
+    public final /*constructor*/ fun <init>(): Y1
+    internal final val x: jet.Int
+}
+internal final class Z : Y {
+    public final /*constructor*/ fun <init>(): Z
+    internal final override /*1*/ val x: jet.Int
+}
@@ -0,0 +1,3 @@
+namespace <root>
+
+internal final fun firstFun(): jet.Tuple0
@@ -0,0 +1,3 @@
+namespace <root>
+
+internal final fun test(): jet.Tuple0
@@ -0,0 +1,12 @@
+namespace <root>
+
+internal abstract trait A</*0*/ T : jet.Any?> : jet.Any {
+}
+internal abstract trait B</*0*/ T : jet.Any?> : jet.Any {
+}
+internal abstract trait C</*0*/ T : jet.Any?> : jet.Any {
+}
+internal abstract trait D</*0*/ T : jet.Any?> : jet.Any {
+}
+internal abstract trait Test : A<in jet.Int>, B<out jet.Int>, C<out jet.Any?>?, D<jet.Int> {
+}
@@ -0,0 +1,8 @@
+namespace <root>
+
+// <namespace name="qualified_expressions">
+namespace qualified_expressions
+
+internal final fun jet.String.startsWith(/*0*/ s: jet.String): jet.Boolean
+internal final fun test(/*0*/ s: jet.String?): jet.Tuple0
+// </namespace name="qualified_expressions">
@@ -0,0 +1,44 @@
+namespace <root>
+
+// <namespace name="a">
+namespace a
+
+internal final val foo: [ERROR : Error function type]
+internal final fun bar(): [ERROR : Error function type]
+// </namespace name="a">
+// <namespace name="b">
+namespace b
+
+internal final fun bar(): [ERROR : Error function type]
+internal final fun foo(): [ERROR : Error function type]
+// </namespace name="b">
+// <namespace name="c">
+namespace c
+
+internal final fun bar(): [ERROR : Error function type]
+internal final fun bazz(): [ERROR : Error function type]
+internal final fun foo(): [ERROR : Error function type]
+// </namespace name="c">
+// <namespace name="ok">
+namespace ok
+
+// <namespace name="a">
+namespace a
+
+internal final val foo: jet.Int
+internal final fun bar(): jet.Int
+// </namespace name="a">
+// <namespace name="b">
+namespace b
+
+internal final fun bar(): jet.Int
+internal final fun foo(): jet.Int
+// </namespace name="b">
+// <namespace name="c">
+namespace c
+
+internal final fun bar(): jet.Int
+internal final fun bazz(): jet.Int
+internal final fun foo(): jet.Int
+// </namespace name="c">
+// </namespace name="ok">
@@ -0,0 +1,7 @@
+namespace <root>
+
+internal final fun test(): jet.Tuple0
+internal final fun test(/*0*/ a: java.lang.Class<jet.Int>): jet.Tuple0
+internal final fun test(/*0*/ a: java.lang.Comparable<jet.Int>): jet.Tuple0
+internal final fun test(/*0*/ a: java.lang.annotation.RetentionPolicy): jet.Tuple0
+internal final fun test(/*0*/ a: java.util.ArrayList<jet.Int>): jet.Tuple0
@@ -0,0 +1,6 @@
+namespace <root>
+
+internal final class A : jet.Any {
+    public final /*constructor*/ fun <init>(): A
+    internal final fun outer(): jet.Tuple0
+}
@@ -0,0 +1,3 @@
+namespace <root>
+
+internal final fun ff(): jet.Tuple0
@@ -0,0 +1,4 @@
+namespace <root>
+
+internal final fun ff(): jet.Tuple0
+internal final fun jet.Int.gg(): jet.Nothing?
@@ -0,0 +1,50 @@
+namespace <root>
+
+// <namespace name="n">
+namespace n
+
+internal final class n.B : jet.Any {
+    public final /*constructor*/ fun <init>(): n.B
+}
+// </namespace name="n">
+internal final class A : jet.Any {
+    public final /*constructor*/ fun <init>(): A
+}
+internal abstract class XXX : jet.Any {
+    public final /*constructor*/ fun <init>(): XXX
+    internal final val a11: jet.Function1<jet.Int, jet.Int>?
+    internal final val a12: jet.Function1<jet.Int, jet.Int>?
+    internal abstract val a13: jet.ExtensionFunction1<jet.Int, jet.Int, jet.Int>
+    internal abstract val a14: jet.ExtensionFunction1<n.B, jet.Int, jet.Int>
+    internal abstract val a152: jet.ExtensionFunction1<jet.Int?, jet.Int, jet.Int>
+    internal abstract val a15: jet.ExtensionFunction1<jet.Int?, jet.Int, jet.Int>
+    internal abstract val a16: jet.Function1<jet.Int, jet.Function1<jet.Int, jet.Int>>
+    internal abstract val a17: jet.ExtensionFunction1<jet.Function1<jet.Int, jet.Int>, jet.Int, jet.Int>
+    internal abstract val a18: jet.Function1<jet.Int, jet.Function1<jet.Int, jet.Int>>
+    internal abstract val a19: jet.Function1<jet.Function1<jet.Int, jet.Int>, jet.Int>
+    internal abstract val a1: [ERROR : package.Int]
+    internal abstract val a2: n.B
+    internal abstract val a31: n.B
+    internal abstract val a3: A
+    internal abstract val a4: A?
+    internal abstract val a5: A?
+    internal abstract val a6: A?
+    internal abstract val a7: jet.Function1<A, n.B>
+    internal abstract val a8: jet.Function2<A, n.B, n.B>
+    internal abstract val a: jet.Int
+}
+internal abstract class YYY : jet.Any {
+    public final /*constructor*/ fun <init>(): YYY
+    internal final val a11: jet.Function1<jet.Int, jet.Int>?
+    internal final val a12: jet.Function1<jet.Int, jet.Int>?
+    internal abstract val a13: jet.ExtensionFunction1<jet.Int, jet.Int, jet.Int>
+    internal abstract val a14: jet.ExtensionFunction1<n.B, jet.Int, jet.Int>
+    internal abstract val a152: jet.ExtensionFunction1<jet.Int?, jet.Int, jet.Int>
+    internal abstract val a15: jet.ExtensionFunction1<jet.Int?, jet.Int, jet.Int>
+    internal abstract val a16: jet.Function1<jet.Int, jet.Function1<jet.Int, jet.Int>>
+    internal abstract val a17: jet.ExtensionFunction1<jet.Function1<jet.Int, jet.Int>, jet.Int, jet.Int>
+    internal abstract val a18: jet.Function1<jet.Int, jet.Function1<jet.Int, jet.Int>>
+    internal abstract val a19: jet.Function1<jet.Function1<jet.Int, jet.Int>, jet.Int>
+    internal abstract val a7: jet.Function1<A, n.B>
+    internal abstract val a8: jet.Function2<A, n.B, n.B>
+}
@@ -0,0 +1,7 @@
+namespace <root>
+
+internal final fun foo(/*0*/ a: jet.Any?): jet.Tuple0
+internal final fun </*0*/ T : jet.Any?>getT(): jet.Tuple0
+internal final fun </*0*/ A : jet.Any?, /*1*/ B : jet.Any?>getTT(): jet.Tuple0
+internal final fun </*0*/ A : jet.Any?, /*1*/ B : jet.Any?, /*2*/ C : jet.Any?>getTTT(/*0*/ x: jet.Any): jet.Tuple0
+internal open fun main(): jet.Tuple0
@@ -0,0 +1,3 @@
+namespace <root>
+
+internal final fun demo(): jet.Tuple0
@@ -0,0 +1,43 @@
+namespace <root>
+
+// <namespace name="example">
+namespace example
+
+internal final class example.A</*0*/ E : jet.Any?> : example.C, example.T {
+    public final /*constructor*/ fun </*0*/ E : jet.Any?><init>(): example.A<E>
+    internal final override /*1*/ fun bar(): jet.Tuple0
+    internal final class example.A.B : example.T {
+        public final /*constructor*/ fun <init>(): example.A.B
+        internal open override /*1*/ fun foo(): jet.Tuple0
+        internal final fun test(): jet.Tuple0
+    }
+    internal open override /*1*/ fun foo(): jet.Tuple0
+    internal final fun test(): jet.Tuple0
+}
+internal final class example.A1 : jet.Any {
+    public final /*constructor*/ fun <init>(): example.A1
+    internal final fun test(): jet.Tuple0
+}
+internal open class example.C : jet.Any {
+    public final /*constructor*/ fun <init>(): example.C
+    internal final fun bar(): jet.Tuple0
+}
+internal final class example.CG : example.G<jet.Int> {
+    public final /*constructor*/ fun <init>(): example.CG
+    internal open override /*1*/ fun foo(): jet.Tuple0
+    internal final fun test(): jet.Tuple0
+}
+internal final class example.ERROR</*0*/ E : jet.Any?> {
+    public final /*constructor*/ fun </*0*/ E : jet.Any?><init>(): example.ERROR<E>
+    internal final fun test(): jet.Tuple0
+}
+internal abstract trait example.G</*0*/ T : jet.Any?> : jet.Any {
+    internal open fun foo(): jet.Tuple0
+}
+internal abstract trait example.T : jet.Any {
+    internal open fun foo(): jet.Tuple0
+}
+internal final fun any(/*0*/ a: jet.Any): jet.Tuple0
+internal final fun foo(): jet.Tuple0
+internal final fun notAnExpression(): jet.Tuple0
+// </namespace name="example">
@@ -0,0 +1,3 @@
+namespace <root>
+
+internal final fun get(): jet.Tuple0
@@ -0,0 +1,3 @@
+namespace <root>
+
+internal final fun f(): jet.Tuple0
@@ -0,0 +1,9 @@
+namespace <root>
+
+internal final class C</*0*/ T : jet.Any?> : jet.Any {
+    public final /*constructor*/ fun </*0*/ T : jet.Any?><init>(): C<T>
+    internal final fun foo(): T
+}
+internal final fun </*0*/ T : jet.Any?>bar(): C<T>
+internal final fun foo(/*0*/ c: C<jet.Int>): jet.Tuple0
+internal final fun main(/*0*/ args: jet.Array<jet.String>): jet.Tuple0
@@ -0,0 +1,3 @@
+namespace <root>
+
+internal final fun foo(/*0*/ f: jet.Function0<jet.Tuple0>): jet.Tuple0
@@ -0,0 +1,25 @@
+namespace <root>
+
+internal final fun blockAndAndMismatch(): jet.Boolean
+internal final fun fail(): jet.Nothing
+internal final fun failtest(/*0*/ a: jet.Int): jet.Int
+internal final fun foo(/*0*/ a: jet.Nothing): jet.Tuple0
+internal final fun nullIsNotNothing(): jet.Tuple0
+internal final fun returnInWhile(/*0*/ a: jet.Int): jet.Tuple0
+internal final fun t1(): jet.Int
+internal final fun t1a(): jet.Int
+internal final fun t1b(): jet.Int
+internal final fun t1c(): jet.Int
+internal final fun t2(): jet.Int
+internal final fun t2a(): jet.Int
+internal final fun t3(): jet.Any
+internal final fun t4(/*0*/ a: jet.Boolean): jet.Int
+internal final fun t4break(/*0*/ a: jet.Boolean): jet.Int
+internal final fun t5(): jet.Int
+internal final fun t6(): jet.Int
+internal final fun t6break(): jet.Int
+internal final fun t7(): jet.Int
+internal final fun t7(/*0*/ b: jet.Int): jet.Int
+internal final fun t7break(/*0*/ b: jet.Int): jet.Int
+internal final fun t8(): jet.Int
+internal final fun tf(): jet.Int
@@ -0,0 +1,9 @@
+namespace <root>
+
+// <namespace name="unresolved">
+namespace unresolved
+
+internal final fun foo1(/*0*/ i: jet.Int): jet.Tuple0
+internal final fun testGenericArgumentsCount(): jet.Tuple0
+internal final fun testUnresolved(): jet.Tuple0
+// </namespace name="unresolved">
@@ -0,0 +1,31 @@
+namespace <root>
+
+// <namespace name="unused_variables">
+namespace unused_variables
+
+internal final class unused_variables.IncDec : jet.Any {
+    public final /*constructor*/ fun <init>(): unused_variables.IncDec
+    internal final fun dec(): unused_variables.IncDec
+    internal final fun inc(): unused_variables.IncDec
+}
+internal final class unused_variables.MyTest : jet.Any {
+    public final /*constructor*/ fun <init>(): unused_variables.MyTest
+    internal final var a: jet.String
+    internal final fun doSmth(/*0*/ a: jet.Any): jet.Tuple0
+    internal final fun doSmth(/*0*/ s: jet.String): jet.Tuple0
+    internal final fun testFor(): jet.Tuple0
+    internal final fun testIf(): jet.Tuple0
+    internal final fun testIncDec(): jet.Tuple0
+    internal final fun testSimple(): jet.Tuple0
+    internal final fun testWhile(): jet.Tuple0
+}
+internal abstract trait unused_variables.Trait : jet.Any {
+    internal abstract fun foo(): jet.Tuple0
+}
+internal final fun doSmth(/*0*/ i: jet.Int): jet.Tuple0
+internal final fun testBackingFieldsNotMarked(): jet.Tuple0
+internal final fun testFunctionLiterals(): jet.Tuple0
+internal final fun testInnerFunctions(): jet.Tuple0
+internal final fun testObject(): unused_variables.Trait
+internal final fun testSimpleCases(): jet.Tuple0
+// </namespace name="unused_variables">
@@ -0,0 +1,42 @@
+namespace <root>
+
+internal open class Bar : jet.Any {
+    public final /*constructor*/ fun <init>(): Bar
+    internal final fun v(): jet.Int
+    internal final val v: jet.Int
+}
+internal final class Barr : Bar {
+    public final /*constructor*/ fun <init>(): Barr
+    internal final override /*1*/ fun v(): jet.Int
+    internal final override /*1*/ val v: jet.Int
+}
+internal final class Foo1 : java.util.ArrayList<jet.Int> {
+    public final /*constructor*/ fun <init>(): Foo1
+    public open override /*1*/ fun add(/*0*/ p0: jet.Int): jet.Boolean
+    public open override /*1*/ fun add(/*0*/ p0: jet.Int, /*1*/ p1: jet.Int): jet.Tuple0
+    public open override /*1*/ fun addAll(/*0*/ p0: java.util.Collection<out jet.Int>): jet.Boolean
+    public open override /*1*/ fun addAll(/*0*/ p0: jet.Int, /*1*/ p1: java.util.Collection<out jet.Int>): jet.Boolean
+    public open override /*1*/ fun clear(): jet.Tuple0
+    public open override /*1*/ fun contains(/*0*/ p0: jet.Any?): jet.Boolean
+    public open override /*1*/ fun containsAll(/*0*/ p0: java.util.Collection<out jet.Any?>): jet.Boolean
+    public open override /*1*/ fun ensureCapacity(/*0*/ p0: jet.Int): jet.Tuple0
+    public open override /*1*/ fun get(/*0*/ p0: jet.Int): jet.Int
+    public open override /*1*/ fun indexOf(/*0*/ p0: jet.Any?): jet.Int
+    public open override /*1*/ fun isEmpty(): jet.Boolean
+    public open override /*1*/ fun iterator(): java.util.Iterator<jet.Int>
+    public open override /*1*/ fun lastIndexOf(/*0*/ p0: jet.Any?): jet.Int
+    public open override /*1*/ fun listIterator(): java.util.ListIterator<jet.Int>
+    public open override /*1*/ fun listIterator(/*0*/ p0: jet.Int): java.util.ListIterator<jet.Int>
+    protected final override /*1*/ var modCount: jet.Int
+    public open override /*1*/ fun remove(/*0*/ p0: jet.Any?): jet.Boolean
+    public open override /*1*/ fun remove(/*0*/ p0: jet.Int): jet.Int
+    public open override /*1*/ fun removeAll(/*0*/ p0: java.util.Collection<out jet.Any?>): jet.Boolean
+    protected open override /*1*/ fun removeRange(/*0*/ p0: jet.Int, /*1*/ p1: jet.Int): jet.Tuple0
+    public open override /*1*/ fun retainAll(/*0*/ p0: java.util.Collection<out jet.Any?>): jet.Boolean
+    public open override /*1*/ fun set(/*0*/ p0: jet.Int, /*1*/ p1: jet.Int): jet.Int
+    public open override /*1*/ fun size(): jet.Int
+    public open override /*1*/ fun subList(/*0*/ p0: jet.Int, /*1*/ p1: jet.Int): java.util.List<jet.Int>
+    public open override /*1*/ fun toArray(): jet.Array<jet.Any?>
+    public open override /*1*/ fun </*0*/ T : jet.Any?>toArray(/*0*/ p0: jet.Array<T>): jet.Array<T>
+    public open override /*1*/ fun trimToSize(): jet.Tuple0
+}
@@ -0,0 +1,12 @@
+namespace <root>
+
+internal final fun foob(/*0*/ vararg a: jet.Boolean /*jet.BooleanArray*/): jet.BooleanArray
+internal final fun foob(/*0*/ vararg a: jet.Byte /*jet.ByteArray*/): jet.ByteArray
+internal final fun fooc(/*0*/ vararg a: jet.Char /*jet.CharArray*/): jet.CharArray
+internal final fun food(/*0*/ vararg a: jet.Double /*jet.DoubleArray*/): jet.DoubleArray
+internal final fun foof(/*0*/ vararg a: jet.Float /*jet.FloatArray*/): jet.FloatArray
+internal final fun fooi(/*0*/ vararg a: jet.Int /*jet.IntArray*/): jet.IntArray
+internal final fun fool(/*0*/ vararg a: jet.Long /*jet.LongArray*/): jet.LongArray
+internal final fun foos(/*0*/ vararg a: jet.Short /*jet.ShortArray*/): jet.ShortArray
+internal final fun foos(/*0*/ vararg a: jet.String /*jet.Array<jet.String>*/): jet.Array<jet.String>
+internal final fun test(): jet.Tuple0
@@ -0,0 +1,5 @@
+namespace <root>
+
+internal final fun test(): jet.Tuple0
+internal final fun v(/*0*/ x: jet.Int, /*1*/ y: jet.String, /*2*/ vararg f: jet.Long /*jet.LongArray*/): jet.Tuple0
+internal final fun v1(/*0*/ vararg f: jet.Function1<jet.Int, jet.Tuple0> /*jet.Array<jet.Function1<jet.Int, jet.Tuple0>>*/): jet.Tuple0
@@ -0,0 +1,28 @@
+namespace <root>
+
+// <namespace name="variance">
+namespace variance
+
+internal final class variance.Array</*0*/ T : jet.Any?> : jet.Any {
+    public final /*constructor*/ fun </*0*/ T : jet.Any?><init>(/*0*/ length: jet.Int, /*1*/ t: T): variance.Array<T>
+    internal final fun get(/*0*/ index: jet.Int): T
+    internal final val length: jet.Int
+    internal final fun set(/*0*/ index: jet.Int, /*1*/ value: T): jet.Tuple0
+    internal final val t: T
+}
+internal abstract class variance.Consumer</*0*/ in T : jet.Any?> : jet.Any {
+    public final /*constructor*/ fun </*0*/ in T : jet.Any?><init>(): variance.Consumer<T>
+}
+internal abstract class variance.Producer</*0*/ out T : jet.Any?> : jet.Any {
+    public final /*constructor*/ fun </*0*/ out T : jet.Any?><init>(): variance.Producer<T>
+}
+internal abstract class variance.Usual</*0*/ T : jet.Any?> : jet.Any {
+    public final /*constructor*/ fun </*0*/ T : jet.Any?><init>(): variance.Usual<T>
+}
+internal final fun copy1(/*0*/ from: variance.Array<jet.Any>, /*1*/ to: variance.Array<jet.Any>): jet.Tuple0
+internal final fun copy2(/*0*/ from: variance.Array<out jet.Any>, /*1*/ to: variance.Array<in jet.Any>): jet.Tuple0
+internal final fun </*0*/ T : jet.Any?>copy3(/*0*/ from: variance.Array<out T>, /*1*/ to: variance.Array<in T>): jet.Tuple0
+internal final fun copy4(/*0*/ from: variance.Array<out jet.Number>, /*1*/ to: variance.Array<in jet.Int>): jet.Tuple0
+internal final fun f(/*0*/ ints: variance.Array<jet.Int>, /*1*/ any: variance.Array<jet.Any>, /*2*/ numbers: variance.Array<jet.Number>): jet.Tuple0
+internal final fun foo(/*0*/ c: variance.Consumer<jet.Int>, /*1*/ p: variance.Producer<jet.Int>, /*2*/ u: variance.Usual<jet.Int>): jet.Tuple0
+// </namespace name="variance">
@@ -0,0 +1,7 @@
+namespace <root>
+
+internal final val _type_test: jet.Int
+internal final val jet.Tuple2<out jet.Int, out jet.Int>.boo: jet.Tuple3<out jet.Int, out jet.Int, out jet.Int>
+internal final fun foo(): jet.Int
+internal final fun jet.Int.foo(): jet.Boolean
+internal final fun test(): jet.Tuple0
@@ -0,0 +1,13 @@
+namespace <root>
+
+// <namespace name="a">
+namespace a
+
+internal final class a.Test : jet.Any {
+    public final /*constructor*/ fun <init>(/*0*/ s: jet.String, /*1*/ x: jet.Int): a.Test
+    internal final java.lang.Deprecated() val s: jet.String
+    internal final java.lang.SuppressWarnings() val x: jet.Int
+}
+internal final java.lang.Deprecated() java.lang.SuppressWarnings() val s: jet.String
+internal final java.lang.Deprecated() java.lang.SuppressWarnings() fun main(/*0*/ args: jet.Array<jet.String>): jet.Tuple0
+// </namespace name="a">
@@ -0,0 +1,8 @@
+namespace <root>
+
+java.lang.Deprecated() internal final annotation class my : jet.Any {
+    public final /*constructor*/ fun <init>(): my
+}
+java.lang.Deprecated() internal final annotation class my1 : jet.Any {
+    public final /*constructor*/ fun <init>(): my1
+}
@@ -0,0 +1,4 @@
+namespace <root>
+
+internal final java.lang.Deprecated() fun foo(): jet.Tuple0
+internal final java.lang.Deprecated() fun foo1(): jet.Tuple0
@@ -0,0 +1,8 @@
+namespace <root>
+
+Foo() internal final class Bar : jet.Any {
+    public final /*constructor*/ fun <init>(): Bar
+}
+internal final class Foo : jet.Any {
+    public final /*constructor*/ fun <init>(): Foo
+}
@@ -0,0 +1,8 @@
+namespace <root>
+
+internal final class Hello : jet.Any {
+    public final /*constructor*/ fun <init>(/*0*/ args: jet.Any): Hello
+}
+internal final var bar: jet.Int
+internal final val x: jet.Function1<jet.Int, jet.Int>
+internal final fun foo(/*0*/ f: jet.Int): jet.Tuple0
@@ -0,0 +1,11 @@
+namespace <root>
+
+internal final class Hello : jet.Any {
+    public final /*constructor*/ fun <init>(/*0*/ args: jet.Any): Hello
+}
+internal final annotation class test : jet.Any {
+    public final /*constructor*/ fun <init>(): test
+}
+internal final var bar: jet.Int
+internal final val x: jet.Function1<jet.Int, jet.Int>
+internal final fun foo(/*0*/ f: jet.Int): jet.Tuple0
@@ -0,0 +1,6 @@
+namespace <root>
+
+internal final class Flower : jet.Any {
+    public final /*constructor*/ fun <init>(): Flower
+    internal final var minusOne: jet.Int
+}
@@ -0,0 +1,6 @@
+namespace <root>
+
+internal final class CustomGetVal : jet.Any {
+    public final /*constructor*/ fun <init>(): CustomGetVal
+    internal final val zz: jet.Int
+}
@@ -0,0 +1,7 @@
+namespace <root>
+
+// <namespace name="customGetValGlobal">
+namespace customGetValGlobal
+
+internal final val zz: jet.Int
+// </namespace name="customGetValGlobal">
@@ -0,0 +1,6 @@
+namespace <root>
+
+internal final class Raise : jet.Any {
+    public final /*constructor*/ fun <init>(): Raise
+    internal final var zz: jet.Int
+}
@@ -0,0 +1,6 @@
+namespace <root>
+
+internal final class Raise : jet.Any {
+    public final /*constructor*/ fun <init>(): Raise
+    internal final var zz: jet.Int
+}
@@ -0,0 +1,6 @@
+namespace <root>
+
+internal final class Cyclic : jet.Any {
+    public final /*constructor*/ fun <init>(): Cyclic
+    internal final val a: [ERROR : Type for $a]
+}
@@ -0,0 +1,6 @@
+namespace <root>
+
+internal final class ReadForward : jet.Any {
+    public final /*constructor*/ fun <init>(): ReadForward
+    internal final val a: jet.Int
+}
@@ -0,0 +1,7 @@
+namespace <root>
+
+internal final class ReadForward : jet.Any {
+    public final /*constructor*/ fun <init>(): ReadForward
+    internal final val a: jet.Int
+    internal final val b: jet.Int
+}
@@ -0,0 +1,6 @@
+namespace <root>
+
+internal final class ReadByAnotherPropertyInitializer : jet.Any {
+    public final /*constructor*/ fun <init>(): ReadByAnotherPropertyInitializer
+    internal final val a: jet.Int
+}
@@ -0,0 +1,7 @@
+namespace <root>
+
+internal final class ReadByAnotherPropertyInitializer : jet.Any {
+    public final /*constructor*/ fun <init>(): ReadByAnotherPropertyInitializer
+    internal final val a: jet.Int
+    internal final val b: jet.Int
+}
@@ -0,0 +1,7 @@
+namespace <root>
+
+internal final class ReadByAnotherPropertyInitializer : jet.Any {
+    public final /*constructor*/ fun <init>(): ReadByAnotherPropertyInitializer
+    internal final val a: jet.Int
+    internal final fun ff(): jet.Int
+}
@@ -0,0 +1,6 @@
+namespace <root>
+
+internal abstract class ReadNonexistent : jet.Any {
+    public final /*constructor*/ fun <init>(): ReadNonexistent
+    internal abstract val aa: jet.Int
+}
@@ -0,0 +1,7 @@
+namespace <root>
+
+internal abstract class ReadNonexistent : jet.Any {
+    public final /*constructor*/ fun <init>(): ReadNonexistent
+    internal abstract val aa: jet.Int
+    internal final fun ff(): jet.Int
+}
@@ -0,0 +1,6 @@
+namespace <root>
+
+internal final class ReadNonexistent : jet.Any {
+    public final /*constructor*/ fun <init>(): ReadNonexistent
+    internal final val a: jet.Int
+}
@@ -0,0 +1,7 @@
+namespace <root>
+
+internal final class CustomValNoBackingField : jet.Any {
+    public final /*constructor*/ fun <init>(): CustomValNoBackingField
+    internal final val a: jet.Int
+    internal final val b: jet.Int
+}
@@ -0,0 +1,7 @@
+namespace <root>
+
+internal final class CustomValNoBackingField : jet.Any {
+    public final /*constructor*/ fun <init>(): CustomValNoBackingField
+    internal final val a: jet.Int
+    internal final val b: jet.Int
+}
@@ -0,0 +1,5 @@
+namespace <root>
+
+internal final class Cl : jet.Any {
+    public final /*constructor*/ fun <init>(): Cl
+}
@@ -0,0 +1,6 @@
+namespace <root>
+
+internal final class A : jet.Any {
+    public final /*constructor*/ fun <init>(): A
+}
+internal final val y: jet.Int
@@ -0,0 +1,11 @@
+namespace <root>
+
+// <namespace name="kt782">
+namespace kt782
+
+internal final val w: jet.Int
+internal final val x: jet.Int
+internal final val y: jet.Int
+internal final val z: jet.Int
+internal final fun foo(): jet.Tuple0
+// </namespace name="kt782">
@@ -0,0 +1,3 @@
+namespace <root>
+
+internal final fun ff(/*0*/ c: java.util.Collection<jet.String>): java.util.List<jet.Int>
@@ -0,0 +1,3 @@
+namespace <root>
+
+internal final fun ff(/*0*/ c: java.util.Collection<jet.String>): java.util.List<jet.String>
@@ -0,0 +1,3 @@
+namespace <root>
+
+internal final fun ff(/*0*/ l: jet.Any): java.util.List<out jet.Any?>
--- a/Show More
+++ b/Show More