Removed test data and generator for test which is "temporarily" disabled.
This commit is contained in:
Evgeny Gerashchenko
@@ -1,49 +0,0 @@
|
||||
namespace <root>
|
||||
|
||||
// <namespace name="MyNamespace">
|
||||
namespace MyNamespace
|
||||
|
||||
internal final val a: jet.Int
|
||||
internal final val a1: jet.Int
|
||||
internal abstract val a2: jet.Int
|
||||
internal abstract val a3: jet.Int
|
||||
internal final var b: jet.Int private set
|
||||
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 c: jet.Int
|
||||
internal final var c1: jet.Int
|
||||
internal abstract var c2: jet.Int
|
||||
internal abstract var c3: jet.Int
|
||||
internal final val e: jet.Int
|
||||
internal final val e1: jet.Int
|
||||
internal abstract val e2: jet.Int
|
||||
internal abstract val e3: jet.Int
|
||||
internal final var i: jet.Int
|
||||
internal final var i1: jet.Int
|
||||
internal final var j: jet.Int
|
||||
internal final var j1: jet.Int
|
||||
internal final var k: jet.Int
|
||||
internal final var k1: jet.Int
|
||||
internal final var l: jet.Int
|
||||
internal final var l1: jet.Int
|
||||
internal final var n: jet.Int
|
||||
internal final fun f(): jet.Tuple0
|
||||
internal final fun g(): jet.Tuple0
|
||||
internal abstract fun h(): jet.Tuple0
|
||||
internal abstract fun j(): jet.Tuple0
|
||||
// </namespace name="MyNamespace">
|
||||
internal abstract class B1 : jet.Any {
|
||||
public final /*constructor*/ fun <init>(/*0*/ i: jet.Int, /*1*/ s: jet.String): B1
|
||||
internal final val i: jet.Int
|
||||
internal final val s: jet.String
|
||||
}
|
||||
internal final class B2 : B1 {
|
||||
public final /*constructor*/ fun <init>(): B2
|
||||
internal final override /*1*/ val i: jet.Int
|
||||
internal final override /*1*/ val s: jet.String
|
||||
}
|
||||
internal abstract class B3 : jet.Any {
|
||||
public final /*constructor*/ fun <init>(/*0*/ i: jet.Int): B3
|
||||
}
|
||||
internal final fun foo(/*0*/ c: B3): jet.Tuple0
|
||||
@@ -1,12 +0,0 @@
|
||||
namespace <root>
|
||||
|
||||
// <namespace name="abstract">
|
||||
namespace abstract
|
||||
|
||||
internal abstract enum class abstract.MyAbstractEnum : jet.Any {
|
||||
public final /*constructor*/ fun <init>(): abstract.MyAbstractEnum
|
||||
internal final class object abstract.MyAbstractEnum.<class-object-for-MyAbstractEnum> {
|
||||
internal final /*constructor*/ fun <init>(): abstract.MyAbstractEnum.<class-object-for-MyAbstractEnum>
|
||||
}
|
||||
}
|
||||
// </namespace name="abstract">
|
||||
@@ -1,38 +0,0 @@
|
||||
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">
|
||||
@@ -1,38 +0,0 @@
|
||||
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">
|
||||
@@ -1,41 +0,0 @@
|
||||
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 class object abstract.MyEnum.<class-object-for-MyEnum> {
|
||||
internal final /*constructor*/ fun <init>(): abstract.MyEnum.<class-object-for-MyEnum>
|
||||
}
|
||||
}
|
||||
// </namespace name="abstract">
|
||||
@@ -1,37 +0,0 @@
|
||||
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">
|
||||
@@ -1,6 +0,0 @@
|
||||
namespace <root>
|
||||
|
||||
internal final class A : jet.Any {
|
||||
public final /*constructor*/ fun <init>(/*0*/ w: jet.Int): A
|
||||
internal final var c: jet.Int
|
||||
}
|
||||
@@ -1,10 +0,0 @@
|
||||
namespace <root>
|
||||
|
||||
internal abstract trait NoC : jet.Any {
|
||||
internal open val a: jet.Int
|
||||
}
|
||||
internal final class WithC : jet.Any {
|
||||
public final /*constructor*/ fun <init>(): WithC
|
||||
internal final val a: jet.Int
|
||||
internal final val x: jet.Int
|
||||
}
|
||||
@@ -1,13 +0,0 @@
|
||||
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
|
||||
@@ -1,10 +0,0 @@
|
||||
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
|
||||
@@ -1,28 +0,0 @@
|
||||
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 class 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">
|
||||
@@ -1,9 +0,0 @@
|
||||
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
|
||||
@@ -1,15 +0,0 @@
|
||||
namespace <root>
|
||||
|
||||
internal final class A : jet.Any {
|
||||
public final /*constructor*/ fun <init>(): A
|
||||
internal final fun equals(/*0*/ a: jet.Any?): jet.Boolean
|
||||
}
|
||||
internal final class B : jet.Any {
|
||||
public final /*constructor*/ fun <init>(): B
|
||||
internal final fun equals(/*0*/ a: jet.Any?): jet.Boolean?
|
||||
}
|
||||
internal final class C : jet.Any {
|
||||
public final /*constructor*/ fun <init>(): C
|
||||
internal final fun equals(/*0*/ a: jet.Any?): jet.Int
|
||||
}
|
||||
internal final fun f(): jet.Tuple0
|
||||
@@ -1,38 +0,0 @@
|
||||
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
|
||||
@@ -1,13 +0,0 @@
|
||||
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
|
||||
}
|
||||
@@ -1,208 +0,0 @@
|
||||
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
|
||||
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
|
||||
invisible_fake abstract override /*1*/ fun renderAttributes(): jet.String?
|
||||
internal open override /*1*/ fun toString(): jet.String?
|
||||
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
|
||||
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
|
||||
invisible_fake abstract override /*1*/ fun renderAttributes(): jet.String?
|
||||
internal open override /*1*/ fun toString(): jet.String?
|
||||
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
|
||||
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
|
||||
invisible_fake abstract override /*1*/ fun renderAttributes(): jet.String?
|
||||
internal open override /*1*/ fun toString(): jet.String?
|
||||
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
|
||||
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
|
||||
invisible_fake abstract override /*1*/ fun renderAttributes(): jet.String?
|
||||
internal open override /*1*/ fun toString(): jet.String?
|
||||
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 open fun toString(): jet.String?
|
||||
}
|
||||
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
|
||||
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
|
||||
invisible_fake abstract override /*1*/ fun renderAttributes(): jet.String?
|
||||
internal open override /*1*/ fun toString(): jet.String?
|
||||
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
|
||||
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
|
||||
invisible_fake abstract override /*1*/ fun renderAttributes(): jet.String?
|
||||
internal open override /*1*/ fun toString(): jet.String?
|
||||
}
|
||||
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
|
||||
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
|
||||
invisible_fake abstract override /*1*/ fun renderAttributes(): jet.String?
|
||||
internal final fun title(/*0*/ init: jet.ExtensionFunction0<html.Title, jet.Tuple0>): html.Title
|
||||
internal open override /*1*/ fun toString(): jet.String?
|
||||
}
|
||||
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
|
||||
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
|
||||
invisible_fake abstract override /*1*/ fun renderAttributes(): jet.String?
|
||||
internal open override /*1*/ fun toString(): jet.String?
|
||||
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
|
||||
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
|
||||
invisible_fake abstract override /*1*/ fun renderAttributes(): jet.String?
|
||||
internal open override /*1*/ fun toString(): jet.String?
|
||||
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 open override /*1*/ fun toString(): 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
|
||||
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
|
||||
invisible_fake abstract override /*1*/ fun renderAttributes(): jet.String?
|
||||
internal open override /*1*/ fun toString(): jet.String?
|
||||
}
|
||||
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 open override /*1*/ fun toString(): 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
|
||||
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
|
||||
invisible_fake abstract override /*1*/ fun renderAttributes(): jet.String?
|
||||
internal open override /*1*/ fun toString(): jet.String?
|
||||
}
|
||||
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
|
||||
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
|
||||
invisible_fake abstract override /*1*/ fun renderAttributes(): jet.String?
|
||||
internal open override /*1*/ fun toString(): jet.String?
|
||||
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">
|
||||
@@ -1,3 +0,0 @@
|
||||
namespace <root>
|
||||
|
||||
internal final fun test(): jet.Tuple0
|
||||
@@ -1,3 +0,0 @@
|
||||
namespace <root>
|
||||
|
||||
internal final fun test(/*0*/ c: jet.Char): jet.Tuple0
|
||||
@@ -1,10 +0,0 @@
|
||||
namespace <root>
|
||||
|
||||
internal final class A : jet.Any {
|
||||
public final /*constructor*/ fun <init>(): A
|
||||
internal final val x: jet.Int
|
||||
internal final class object A.<no name provided> : jet.Any {
|
||||
internal final /*constructor*/ fun <init>(): A.<no name provided>
|
||||
internal final val y: [ERROR : Type for x]
|
||||
}
|
||||
}
|
||||
@@ -1,22 +0,0 @@
|
||||
namespace <root>
|
||||
|
||||
// <namespace name="foo">
|
||||
namespace foo
|
||||
|
||||
internal final class foo.A : jet.Any {
|
||||
public final /*constructor*/ fun <init>(): foo.A
|
||||
public final class object foo.A.<no name provided> : jet.Any {
|
||||
internal final /*constructor*/ fun <init>(): foo.A.<no name provided>
|
||||
internal final val d: jet.Int
|
||||
private final val f: foo.A.<no name provided>.f
|
||||
}
|
||||
}
|
||||
internal final class foo.CCC : jet.Any {
|
||||
public final /*constructor*/ fun <init>(): foo.CCC
|
||||
private final class object foo.CCC.<no name provided> : jet.Any {
|
||||
internal final /*constructor*/ fun <init>(): foo.CCC.<no name provided>
|
||||
internal final val classObjectVar: jet.Int
|
||||
}
|
||||
}
|
||||
internal final fun test(): jet.Tuple0
|
||||
// </namespace name="foo">
|
||||
@@ -1,23 +0,0 @@
|
||||
namespace <root>
|
||||
|
||||
// <namespace name="Jet86">
|
||||
namespace Jet86
|
||||
|
||||
internal final class Jet86.A : jet.Any {
|
||||
public final /*constructor*/ fun <init>(): Jet86.A
|
||||
internal final class 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">
|
||||
@@ -1,3 +0,0 @@
|
||||
namespace <root>
|
||||
|
||||
internal final fun test(): jet.Tuple0
|
||||
@@ -1,47 +0,0 @@
|
||||
namespace <root>
|
||||
|
||||
internal final class Foo : WithPC0 {
|
||||
public final /*constructor*/ fun <init>(): Foo
|
||||
}
|
||||
internal open class NoC : jet.Any {
|
||||
public final /*constructor*/ fun <init>(): NoC
|
||||
}
|
||||
internal final class NoC1 : NoC {
|
||||
public final /*constructor*/ fun <init>(): NoC1
|
||||
}
|
||||
internal final class NoC2 : WithC1 {
|
||||
public final /*constructor*/ fun <init>(): NoC2
|
||||
}
|
||||
internal final class NoC3 : WithC1 {
|
||||
public final /*constructor*/ fun <init>(): NoC3
|
||||
}
|
||||
internal final class NoCPI : jet.Any {
|
||||
public final /*constructor*/ fun <init>(): NoCPI
|
||||
internal final val a: jet.Int
|
||||
internal final var ab: jet.Int
|
||||
}
|
||||
internal final class WithC0 : NoC {
|
||||
public final /*constructor*/ fun <init>(): WithC0
|
||||
}
|
||||
internal open class WithC1 : NoC {
|
||||
public final /*constructor*/ fun <init>(): WithC1
|
||||
}
|
||||
internal final class WithC2 : WithC1 {
|
||||
public final /*constructor*/ fun <init>(): WithC2
|
||||
}
|
||||
internal final class WithCPI : jet.Any {
|
||||
public final /*constructor*/ fun <init>(/*0*/ x: jet.Int): WithCPI
|
||||
internal final val a: jet.Int
|
||||
internal final val b: jet.Int
|
||||
internal final val xy: jet.Int
|
||||
}
|
||||
internal final class WithCPI_Dup : jet.Any {
|
||||
public final /*constructor*/ fun <init>(/*0*/ x: jet.Int): WithCPI_Dup
|
||||
internal final var x: jet.Int
|
||||
}
|
||||
internal final class WithPC0 : jet.Any {
|
||||
public final /*constructor*/ fun <init>(): WithPC0
|
||||
}
|
||||
internal final class WithPC1 : jet.Any {
|
||||
public final /*constructor*/ fun <init>(/*0*/ a: jet.Int): WithPC1
|
||||
}
|
||||
@@ -1,23 +0,0 @@
|
||||
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>
|
||||
}
|
||||
@@ -1,18 +0,0 @@
|
||||
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
|
||||
@@ -1,10 +0,0 @@
|
||||
namespace <root>
|
||||
|
||||
internal final class A : jet.Any {
|
||||
public final /*constructor*/ fun <init>(/*0*/ x: jet.Int = ?, /*1*/ y: jet.Int = ?): A
|
||||
internal final fun foo(/*0*/ bool: jet.Boolean, /*1*/ a: jet.Int = ?, /*2*/ b: jet.String = ?): jet.Tuple0
|
||||
}
|
||||
internal final val x: jet.String
|
||||
internal final val z: jet.Int
|
||||
internal final fun bar(/*0*/ x: jet.Int = ?, /*1*/ y: jet.Int = ?, /*2*/ z: jet.String = ?): jet.Tuple0
|
||||
internal final fun foo(/*0*/ x: jet.Int = ?, /*1*/ y: jet.Int = ?, /*2*/ i: jet.Int = ?): jet.Int
|
||||
@@ -1,5 +0,0 @@
|
||||
namespace <root>
|
||||
|
||||
internal abstract trait T : jet.Any {
|
||||
internal open val a: [ERROR : <ERROR FUNCTION RETURN TYPE>]
|
||||
}
|
||||
@@ -1,41 +0,0 @@
|
||||
namespace <root>
|
||||
|
||||
internal open class Br : T {
|
||||
public final /*constructor*/ fun <init>(/*0*/ t: T): Br
|
||||
internal abstract override /*1*/ fun foo(): jet.Tuple0
|
||||
internal abstract override /*1*/ val v: jet.Int
|
||||
}
|
||||
internal open class Br1 : T {
|
||||
public final /*constructor*/ fun <init>(/*0*/ t: T): Br1
|
||||
internal open override /*1*/ fun foo(): jet.Tuple0
|
||||
internal open override /*1*/ val v: jet.Int
|
||||
}
|
||||
internal final class Br2 : Br1 {
|
||||
public final /*constructor*/ fun <init>(/*0*/ t: T): Br2
|
||||
internal open override /*1*/ fun foo(): jet.Tuple0
|
||||
internal open override /*1*/ val v: jet.Int
|
||||
}
|
||||
internal final class Br3 : Br {
|
||||
public final /*constructor*/ fun <init>(/*0*/ t: T): Br3
|
||||
internal abstract override /*1*/ fun foo(): jet.Tuple0
|
||||
internal abstract override /*1*/ val v: jet.Int
|
||||
}
|
||||
internal abstract trait G</*0*/ T : jet.Any?> : jet.Any {
|
||||
internal abstract fun foo(/*0*/ t: T): T
|
||||
}
|
||||
internal final class GC : G<jet.Int> {
|
||||
public final /*constructor*/ fun <init>(): GC
|
||||
internal abstract override /*1*/ fun foo(/*0*/ t: jet.Int): jet.Int
|
||||
}
|
||||
internal open class GC1 : G<jet.Int> {
|
||||
public final /*constructor*/ fun <init>(/*0*/ g: G<jet.Int>): GC1
|
||||
internal open override /*1*/ fun foo(/*0*/ t: jet.Int): jet.Int
|
||||
}
|
||||
internal open class GC2 : GC1 {
|
||||
public final /*constructor*/ fun <init>(/*0*/ g: G<jet.Int>): GC2
|
||||
internal open override /*1*/ fun foo(/*0*/ t: jet.Int): jet.Int
|
||||
}
|
||||
internal abstract trait T : jet.Any {
|
||||
internal abstract fun foo(): jet.Tuple0
|
||||
internal abstract val v: jet.Int
|
||||
}
|
||||
@@ -1,22 +0,0 @@
|
||||
namespace <root>
|
||||
|
||||
internal final class Barrr : Foo {
|
||||
public final /*constructor*/ fun <init>(): Barrr
|
||||
}
|
||||
internal final class Br : T {
|
||||
public final /*constructor*/ fun <init>(/*0*/ t: T): Br
|
||||
}
|
||||
internal open enum class E : jet.Any {
|
||||
public final /*constructor*/ fun <init>(): E
|
||||
internal final class object E.<class-object-for-E> {
|
||||
internal final /*constructor*/ fun <init>(): E.<class-object-for-E>
|
||||
}
|
||||
}
|
||||
internal open class Foo : jet.Any {
|
||||
public final /*constructor*/ fun <init>(): Foo
|
||||
}
|
||||
internal abstract trait T : jet.Any {
|
||||
}
|
||||
internal final class Test2 : E {
|
||||
public final /*constructor*/ fun <init>(/*0*/ e: E): Test2
|
||||
}
|
||||
@@ -1,17 +0,0 @@
|
||||
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
|
||||
}
|
||||
@@ -1,17 +0,0 @@
|
||||
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
|
||||
}
|
||||
@@ -1,17 +0,0 @@
|
||||
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
|
||||
}
|
||||
@@ -1,17 +0,0 @@
|
||||
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">
|
||||
@@ -1,12 +0,0 @@
|
||||
namespace <root>
|
||||
|
||||
internal final enum class List</*0*/ out T : jet.Any?> : jet.Any {
|
||||
public final /*constructor*/ fun </*0*/ out T : jet.Any?><init>(/*0*/ size: jet.Int): List<T>
|
||||
internal final val size: jet.Int
|
||||
internal final class object List.<class-object-for-List> {
|
||||
internal final /*constructor*/ fun <init>(): List.<class-object-for-List>
|
||||
internal final val Nil: List.<class-object-for-List>.Nil
|
||||
}
|
||||
}
|
||||
internal final val foo: List.<class-object-for-List>.Nil
|
||||
internal final val foo1: jet.Int
|
||||
@@ -1,76 +0,0 @@
|
||||
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
|
||||
@@ -1,15 +0,0 @@
|
||||
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">
|
||||
@@ -1,71 +0,0 @@
|
||||
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
|
||||
protected final fun f(): jet.String
|
||||
}
|
||||
internal final val a: jet.Nothing
|
||||
internal final fun bbb(): jet.Tuple0
|
||||
internal final fun blockAndAndMismatch(): jet.Int
|
||||
internal final fun blockAndAndMismatch1(): jet.Int
|
||||
internal final fun blockAndAndMismatch2(): jet.Int
|
||||
internal final fun blockAndAndMismatch3(): jet.Int
|
||||
internal final fun blockAndAndMismatch4(): jet.Int
|
||||
internal final fun blockAndAndMismatch5(): jet.Int
|
||||
internal final fun blockNoReturnIfEmptyIf(): jet.Int
|
||||
internal final fun blockNoReturnIfUnitInOneBranch(): jet.Int
|
||||
internal final fun blockNoReturnIfValDeclaration(): jet.Int
|
||||
internal final fun blockReturnUnitMismatch(): jet.Int
|
||||
internal final fun blockReturnValueTypeMatch(): jet.Int
|
||||
internal final fun blockReturnValueTypeMatch1(): jet.Int
|
||||
internal final fun blockReturnValueTypeMatch10(): jet.Int
|
||||
internal final fun blockReturnValueTypeMatch11(): jet.Int
|
||||
internal final fun blockReturnValueTypeMatch12(): jet.Int
|
||||
internal final fun blockReturnValueTypeMatch2(): jet.Int
|
||||
internal final fun blockReturnValueTypeMatch3(): jet.Int
|
||||
internal final fun blockReturnValueTypeMatch4(): jet.Int
|
||||
internal final fun blockReturnValueTypeMatch5(): jet.Int
|
||||
internal final fun blockReturnValueTypeMatch6(): jet.Int
|
||||
internal final fun blockReturnValueTypeMatch7(): jet.Int
|
||||
internal final fun blockReturnValueTypeMatch8(): jet.Int
|
||||
internal final fun blockReturnValueTypeMatch9(): jet.Int
|
||||
internal final fun blockReturnValueTypeMismatch(): jet.Int
|
||||
internal final fun blockReturnValueTypeMismatchUnit(): jet.Int
|
||||
internal final fun f(): jet.Int
|
||||
internal final fun f1(): jet.Int
|
||||
public final fun f2(): jet.Int
|
||||
internal final fun foo(/*0*/ expr: java.lang.StringBuilder): jet.Int
|
||||
internal final fun illegalConstantBlock(): jet.String
|
||||
internal final fun illegalConstantBody(): jet.Int
|
||||
internal final fun illegalIfBlock(): jet.Boolean
|
||||
internal final fun illegalIfBody(): jet.Int
|
||||
internal final fun illegalReturnIf(): jet.Char
|
||||
internal final fun intBlock(): jet.Int
|
||||
internal final fun intBlock1(): jet.Int
|
||||
internal final fun intEmpty(): jet.Int
|
||||
internal final fun intFunctionLiteral(): jet.Int
|
||||
internal final fun intShort(): jet.Int
|
||||
internal final fun intShortInfer(): jet.Int
|
||||
internal final fun intString(): jet.Int
|
||||
internal final fun nonBlockNoReturnIfUnitInOneBranch(): jet.Int
|
||||
internal final fun nonBlockReturnIfEmptyIf(): jet.Int
|
||||
internal final fun none(): jet.Tuple0
|
||||
internal final fun returnNothing(): jet.Nothing
|
||||
internal final fun test1(): jet.Any
|
||||
internal final fun test2(): jet.Any
|
||||
internal final fun test3(): jet.Any
|
||||
internal final fun test4(): jet.Function0<jet.Tuple0>
|
||||
internal final fun test5(): jet.Any
|
||||
internal final fun test6(): jet.Any
|
||||
internal final fun testFunctionLiterals(): jet.Tuple0
|
||||
internal final fun unitEmpty(): jet.Tuple0
|
||||
internal final fun unitEmptyInfer(): jet.Tuple0
|
||||
internal final fun unitEmptyReturn(): jet.Tuple0
|
||||
internal final fun unitIntReturn(): jet.Tuple0
|
||||
internal final fun unitShort(): jet.Tuple0
|
||||
internal final fun unitShortConv(): jet.Tuple0
|
||||
internal final fun unitShortNull(): jet.Tuple0
|
||||
internal final fun unitUnitReturn(): jet.Tuple0
|
||||
@@ -1,72 +0,0 @@
|
||||
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> {
|
||||
}
|
||||
@@ -1,5 +0,0 @@
|
||||
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
|
||||
@@ -1,21 +0,0 @@
|
||||
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">
|
||||
@@ -1,26 +0,0 @@
|
||||
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">
|
||||
@@ -1,20 +0,0 @@
|
||||
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
|
||||
@@ -1,4 +0,0 @@
|
||||
namespace <root>
|
||||
|
||||
internal final fun ff(): jet.Tuple0
|
||||
internal final fun test(): jet.Tuple0
|
||||
@@ -1,4 +0,0 @@
|
||||
namespace <root>
|
||||
|
||||
internal final fun ff(/*0*/ a: jet.String): jet.Int
|
||||
internal final fun gg(): jet.Tuple0
|
||||
@@ -1,26 +0,0 @@
|
||||
namespace <root>
|
||||
|
||||
internal final class A : jet.Any {
|
||||
public final /*constructor*/ fun <init>(): A
|
||||
internal final class A.B : jet.Any {
|
||||
public final /*constructor*/ fun <init>(): A.B
|
||||
}
|
||||
}
|
||||
internal final class B : jet.Any {
|
||||
public final /*constructor*/ fun <init>(): B
|
||||
internal final class object B.<no name provided> : jet.Any {
|
||||
internal final /*constructor*/ fun <init>(): B.<no name provided>
|
||||
internal final class B.<no name provided>.B : jet.Any {
|
||||
public final /*constructor*/ fun <init>(): B.<no name provided>.B
|
||||
internal final class object B.<no name provided>.B.<no name provided> : jet.Any {
|
||||
internal final /*constructor*/ fun <init>(): B.<no name provided>.B.<no name provided>
|
||||
internal final class B.<no name provided>.B.<no name provided>.C : jet.Any {
|
||||
public final /*constructor*/ fun <init>(): B.<no name provided>.B.<no name provided>.C
|
||||
internal final class object B.<no name provided>.B.<no name provided>.C.<no name provided> : jet.Any {
|
||||
internal final /*constructor*/ fun <init>(): B.<no name provided>.B.<no name provided>.C.<no name provided>
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,3 +0,0 @@
|
||||
namespace <root>
|
||||
|
||||
internal final fun test(): jet.Tuple0
|
||||
@@ -1,47 +0,0 @@
|
||||
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">
|
||||
@@ -1,8 +0,0 @@
|
||||
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">
|
||||
@@ -1,4 +0,0 @@
|
||||
namespace <root>
|
||||
|
||||
internal final fun box(): jet.String
|
||||
internal final fun new(): jet.String
|
||||
@@ -1,54 +0,0 @@
|
||||
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 class 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">
|
||||
@@ -1,5 +0,0 @@
|
||||
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
|
||||
@@ -1,12 +0,0 @@
|
||||
namespace <root>
|
||||
|
||||
// <namespace name="root">
|
||||
namespace root
|
||||
|
||||
// <namespace name="a">
|
||||
namespace a
|
||||
|
||||
// </namespace name="a">
|
||||
internal final val x: [ERROR : Type for a]
|
||||
internal final val y2: [ERROR : Type for package]
|
||||
// </namespace name="root">
|
||||
@@ -1,16 +0,0 @@
|
||||
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">
|
||||
@@ -1,48 +0,0 @@
|
||||
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">
|
||||
@@ -1,13 +0,0 @@
|
||||
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
|
||||
@@ -1,11 +0,0 @@
|
||||
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
|
||||
-10
@@ -1,10 +0,0 @@
|
||||
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
|
||||
@@ -1,17 +0,0 @@
|
||||
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
|
||||
}
|
||||
@@ -1,27 +0,0 @@
|
||||
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
|
||||
}
|
||||
@@ -1,3 +0,0 @@
|
||||
namespace <root>
|
||||
|
||||
internal final fun firstFun(): jet.Tuple0
|
||||
@@ -1,3 +0,0 @@
|
||||
namespace <root>
|
||||
|
||||
internal final fun test(): jet.Tuple0
|
||||
@@ -1,12 +0,0 @@
|
||||
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> {
|
||||
}
|
||||
@@ -1,12 +0,0 @@
|
||||
namespace <root>
|
||||
|
||||
internal final class Test : jet.Any {
|
||||
public final /*constructor*/ fun <init>(): Test
|
||||
internal final var a: jet.Int
|
||||
internal final var b: jet.Int
|
||||
internal final fun f(): jet.Tuple0
|
||||
public final val i: jet.Int
|
||||
}
|
||||
internal final val p: jet.Int
|
||||
internal final var x: jet.Int
|
||||
internal final val xx: jet.Int
|
||||
@@ -1,8 +0,0 @@
|
||||
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">
|
||||
@@ -1,30 +0,0 @@
|
||||
namespace <root>
|
||||
|
||||
// <namespace name="closures">
|
||||
namespace closures
|
||||
|
||||
internal final class closures.A : jet.Any {
|
||||
public final /*constructor*/ fun <init>(/*0*/ a: jet.Int): closures.A
|
||||
internal final val a: jet.Int
|
||||
internal final class closures.A.B : jet.Any {
|
||||
public final /*constructor*/ fun <init>(): closures.A.B
|
||||
internal final fun jet.Char.xx(): jet.Any
|
||||
internal final val jet.Int.xx: jet.Int
|
||||
internal final val x: closures.A.B
|
||||
internal final val y: closures.A
|
||||
internal final val z: closures.A.B
|
||||
}
|
||||
}
|
||||
// </namespace name="closures">
|
||||
internal final class A : jet.Any {
|
||||
public final /*constructor*/ fun <init>(): A
|
||||
internal final fun foo(): jet.Tuple0
|
||||
internal final val x: jet.Tuple0
|
||||
internal final val y: jet.Tuple0
|
||||
internal final val z: jet.Tuple0
|
||||
}
|
||||
internal final class Dup : jet.Any {
|
||||
public final /*constructor*/ fun <init>(): Dup
|
||||
internal final fun Dup(): jet.Tuple0
|
||||
}
|
||||
internal final fun foo1(): jet.Tuple0
|
||||
@@ -1,44 +0,0 @@
|
||||
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">
|
||||
@@ -1,7 +0,0 @@
|
||||
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
|
||||
@@ -1,8 +0,0 @@
|
||||
namespace <root>
|
||||
|
||||
// <namespace name="xxx">
|
||||
namespace xxx
|
||||
|
||||
// </namespace name="xxx">
|
||||
internal final val l: java.util.List<in jet.Int>
|
||||
internal final fun test(/*0*/ l: java.util.List<jet.Int>): jet.Tuple0
|
||||
@@ -1,6 +0,0 @@
|
||||
namespace <root>
|
||||
|
||||
internal final class A : jet.Any {
|
||||
public final /*constructor*/ fun <init>(): A
|
||||
internal final fun outer(): jet.Tuple0
|
||||
}
|
||||
@@ -1,3 +0,0 @@
|
||||
namespace <root>
|
||||
|
||||
internal final fun ff(): jet.Tuple0
|
||||
@@ -1,4 +0,0 @@
|
||||
namespace <root>
|
||||
|
||||
internal final fun ff(): jet.Tuple0
|
||||
internal final fun jet.Int.gg(): jet.Nothing?
|
||||
@@ -1,50 +0,0 @@
|
||||
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>
|
||||
}
|
||||
@@ -1,7 +0,0 @@
|
||||
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
|
||||
@@ -1,3 +0,0 @@
|
||||
namespace <root>
|
||||
|
||||
internal final fun demo(): jet.Tuple0
|
||||
@@ -1,43 +0,0 @@
|
||||
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">
|
||||
@@ -1,50 +0,0 @@
|
||||
namespace <root>
|
||||
|
||||
internal final class C1 : jet.Any {
|
||||
public final /*constructor*/ fun <init>(): C1
|
||||
}
|
||||
internal open class C2 : jet.Any {
|
||||
public final /*constructor*/ fun <init>(): C2
|
||||
}
|
||||
internal open class C3 : jet.Any {
|
||||
public final /*constructor*/ fun <init>(): C3
|
||||
}
|
||||
internal final class CTest1 : OC1 {
|
||||
public final /*constructor*/ fun <init>(): CTest1
|
||||
}
|
||||
internal final class CTest2 : C2 {
|
||||
public final /*constructor*/ fun <init>(): CTest2
|
||||
}
|
||||
internal final class CTest3 : C2, C3 {
|
||||
public final /*constructor*/ fun <init>(): CTest3
|
||||
}
|
||||
internal final class CTest4 : T1 {
|
||||
public final /*constructor*/ fun <init>(): CTest4
|
||||
}
|
||||
internal final class CTest5 : T1, T1 {
|
||||
public final /*constructor*/ fun <init>(): CTest5
|
||||
}
|
||||
internal final class CTest6 : C1 {
|
||||
public final /*constructor*/ fun <init>(): CTest6
|
||||
}
|
||||
internal open class OC1 : jet.Any {
|
||||
public final /*constructor*/ fun <init>(): OC1
|
||||
}
|
||||
internal abstract trait T1 : jet.Any {
|
||||
}
|
||||
internal abstract trait T2</*0*/ T : jet.Any?> : jet.Any {
|
||||
}
|
||||
internal abstract trait Test : jet.Any {
|
||||
}
|
||||
internal abstract trait Test1 : C2 {
|
||||
}
|
||||
internal abstract trait Test2 : C2 {
|
||||
}
|
||||
internal abstract trait Test3 : C2, C3 {
|
||||
}
|
||||
internal abstract trait Test4 : T1 {
|
||||
}
|
||||
internal abstract trait Test5 : T1, T1 {
|
||||
}
|
||||
internal abstract trait Test6 : C1 {
|
||||
}
|
||||
@@ -1,3 +0,0 @@
|
||||
namespace <root>
|
||||
|
||||
internal final fun get(): jet.Tuple0
|
||||
@@ -1,3 +0,0 @@
|
||||
namespace <root>
|
||||
|
||||
internal final fun f(): jet.Tuple0
|
||||
@@ -1,15 +0,0 @@
|
||||
namespace <root>
|
||||
|
||||
internal abstract trait Foo : bar, bar, bar {
|
||||
}
|
||||
internal open class Foo1 : bar, bar, Foo, Foo {
|
||||
public final /*constructor*/ fun <init>(): Foo1
|
||||
}
|
||||
internal open class Foo12 : bar, bar {
|
||||
public final /*constructor*/ fun <init>(): Foo12
|
||||
}
|
||||
internal abstract trait Foo2 : bar, Foo {
|
||||
}
|
||||
internal open class bar : jet.Any {
|
||||
public final /*constructor*/ fun <init>(): bar
|
||||
}
|
||||
@@ -1,9 +0,0 @@
|
||||
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
|
||||
@@ -1,95 +0,0 @@
|
||||
namespace <root>
|
||||
|
||||
// <namespace name="uninitialized_reassigned_variables">
|
||||
namespace uninitialized_reassigned_variables
|
||||
|
||||
internal final class uninitialized_reassigned_variables.A : jet.Any {
|
||||
public final /*constructor*/ fun <init>(): uninitialized_reassigned_variables.A
|
||||
}
|
||||
internal final class uninitialized_reassigned_variables.AnonymousInitializers : jet.Any {
|
||||
public final /*constructor*/ fun <init>(/*0*/ a: jet.String, /*1*/ b: jet.String): uninitialized_reassigned_variables.AnonymousInitializers
|
||||
internal final var a: jet.String
|
||||
internal final val b: jet.String
|
||||
internal final val i: jet.Int
|
||||
internal final val j: jet.Int
|
||||
internal final val k: jet.String
|
||||
internal final val l: jet.String
|
||||
internal final var m: jet.Int
|
||||
internal final val n: jet.Int
|
||||
internal final val o: jet.String
|
||||
internal final var p: jet.Int
|
||||
}
|
||||
internal final class uninitialized_reassigned_variables.ClassObject : jet.Any {
|
||||
public final /*constructor*/ fun <init>(): uninitialized_reassigned_variables.ClassObject
|
||||
internal final class object uninitialized_reassigned_variables.ClassObject.<no name provided> : jet.Any {
|
||||
internal final /*constructor*/ fun <init>(): uninitialized_reassigned_variables.ClassObject.<no name provided>
|
||||
internal final fun foo(): jet.Tuple0
|
||||
internal final val x: jet.Int
|
||||
}
|
||||
}
|
||||
internal final class uninitialized_reassigned_variables.ForwardAccessToBackingField : jet.Any {
|
||||
public final /*constructor*/ fun <init>(): uninitialized_reassigned_variables.ForwardAccessToBackingField
|
||||
internal final val a: [ERROR : Type for $a]
|
||||
internal final val b: jet.Int
|
||||
internal final val c: jet.Int
|
||||
}
|
||||
internal final class uninitialized_reassigned_variables.LocalValsVsProperties : uninitialized_reassigned_variables.Open {
|
||||
public final /*constructor*/ fun <init>(/*0*/ a: jet.Int, /*1*/ w: jet.Int): uninitialized_reassigned_variables.LocalValsVsProperties
|
||||
internal final val a: jet.Int
|
||||
internal final val b: jet.Int
|
||||
internal final fun foo(): jet.Tuple0
|
||||
internal final val x: jet.Int
|
||||
internal final var xx: jet.Int
|
||||
internal final val y: jet.Int
|
||||
internal final var yy: jet.Int
|
||||
}
|
||||
internal final class uninitialized_reassigned_variables.M : jet.Any {
|
||||
public final /*constructor*/ fun <init>(): uninitialized_reassigned_variables.M
|
||||
internal final val x: jet.Int
|
||||
internal final var y: jet.Int
|
||||
}
|
||||
internal open class uninitialized_reassigned_variables.Open : jet.Any {
|
||||
public final /*constructor*/ fun <init>(/*0*/ a: jet.Int, /*1*/ w: jet.Int): uninitialized_reassigned_variables.Open
|
||||
}
|
||||
internal final class uninitialized_reassigned_variables.Outer : jet.Any {
|
||||
public final /*constructor*/ fun <init>(): uninitialized_reassigned_variables.Outer
|
||||
internal final val a: jet.Int
|
||||
internal final var b: jet.Int
|
||||
internal final fun foo(): jet.Tuple0
|
||||
internal final class uninitialized_reassigned_variables.Outer.Inner : jet.Any {
|
||||
public final /*constructor*/ fun <init>(): uninitialized_reassigned_variables.Outer.Inner
|
||||
}
|
||||
}
|
||||
internal abstract enum class uninitialized_reassigned_variables.ProtocolState : jet.Any {
|
||||
public final /*constructor*/ fun <init>(): uninitialized_reassigned_variables.ProtocolState
|
||||
internal abstract fun signal(): uninitialized_reassigned_variables.ProtocolState
|
||||
internal final class object uninitialized_reassigned_variables.ProtocolState.<class-object-for-ProtocolState> {
|
||||
internal final /*constructor*/ fun <init>(): uninitialized_reassigned_variables.ProtocolState.<class-object-for-ProtocolState>
|
||||
internal final val TALKING: uninitialized_reassigned_variables.ProtocolState.<class-object-for-ProtocolState>.TALKING
|
||||
internal final val WAITING: uninitialized_reassigned_variables.ProtocolState.<class-object-for-ProtocolState>.WAITING
|
||||
}
|
||||
}
|
||||
internal final class uninitialized_reassigned_variables.TestObjectExpression : jet.Any {
|
||||
public final /*constructor*/ fun <init>(): uninitialized_reassigned_variables.TestObjectExpression
|
||||
internal final val a: jet.Int
|
||||
internal final fun foo(): jet.Tuple0
|
||||
}
|
||||
internal final val TestObjectDeclaration: uninitialized_reassigned_variables.TestObjectDeclaration
|
||||
internal final var x: jet.Int
|
||||
internal final val y: jet.Int
|
||||
internal final val z: jet.Int
|
||||
internal final fun doSmth(/*0*/ i: jet.Int): jet.Tuple0
|
||||
internal final fun doSmth(/*0*/ s: jet.String): jet.Tuple0
|
||||
internal final fun foo(): jet.Tuple0
|
||||
internal final fun func(): jet.Tuple0
|
||||
internal final fun reassignFunParams(/*0*/ a: jet.Int): jet.Tuple0
|
||||
internal final fun t1(): jet.Tuple0
|
||||
internal final fun t1(/*0*/ b: jet.Boolean): jet.Tuple0
|
||||
internal final fun t2(): jet.Tuple0
|
||||
internal final fun t3(): jet.Tuple0
|
||||
internal final fun t4(): jet.Tuple0
|
||||
internal final fun t4(/*0*/ a: uninitialized_reassigned_variables.A, /*1*/ b: uninitialized_reassigned_variables.A, /*2*/ c: uninitialized_reassigned_variables.A): jet.Tuple0
|
||||
internal final fun t5(): jet.Tuple0
|
||||
internal final fun test(/*0*/ m: uninitialized_reassigned_variables.M): jet.Tuple0
|
||||
internal final fun test1(/*0*/ m: uninitialized_reassigned_variables.M): jet.Tuple0
|
||||
// </namespace name="uninitialized_reassigned_variables">
|
||||
@@ -1,3 +0,0 @@
|
||||
namespace <root>
|
||||
|
||||
internal final fun foo(/*0*/ f: jet.Function0<jet.Tuple0>): jet.Tuple0
|
||||
@@ -1,25 +0,0 @@
|
||||
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
|
||||
@@ -1,9 +0,0 @@
|
||||
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">
|
||||
@@ -1,31 +0,0 @@
|
||||
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">
|
||||
@@ -1,53 +0,0 @@
|
||||
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 clone(): jet.Any
|
||||
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 equals(/*0*/ p0: jet.Any?): jet.Boolean
|
||||
protected open override /*1*/ fun finalize(): jet.Tuple0
|
||||
public open override /*1*/ fun get(/*0*/ p0: jet.Int): jet.Int
|
||||
public final override /*1*/ fun getClass(): java.lang.Class<out jet.Any?>?
|
||||
public open override /*1*/ fun hashCode(): 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 final override /*1*/ fun notify(): jet.Tuple0
|
||||
public final override /*1*/ fun notifyAll(): jet.Tuple0
|
||||
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 toString(): jet.String?
|
||||
public open override /*1*/ fun trimToSize(): jet.Tuple0
|
||||
public final override /*1*/ fun wait(): jet.Tuple0
|
||||
public final override /*1*/ fun wait(/*0*/ p0: jet.Long): jet.Tuple0
|
||||
public final override /*1*/ fun wait(/*0*/ p0: jet.Long, /*1*/ p1: jet.Int): jet.Tuple0
|
||||
}
|
||||
@@ -1,12 +0,0 @@
|
||||
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
|
||||
@@ -1,5 +0,0 @@
|
||||
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
|
||||
@@ -1,28 +0,0 @@
|
||||
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">
|
||||
@@ -1,7 +0,0 @@
|
||||
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
|
||||
@@ -1,13 +0,0 @@
|
||||
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">
|
||||
@@ -1,8 +0,0 @@
|
||||
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
|
||||
}
|
||||
@@ -1,4 +0,0 @@
|
||||
namespace <root>
|
||||
|
||||
internal final java.lang.Deprecated() fun foo(): jet.Tuple0
|
||||
internal final java.lang.Deprecated() fun foo1(): jet.Tuple0
|
||||
@@ -1,8 +0,0 @@
|
||||
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
|
||||
}
|
||||
@@ -1,8 +0,0 @@
|
||||
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
|
||||
@@ -1,11 +0,0 @@
|
||||
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
|
||||
@@ -1,6 +0,0 @@
|
||||
namespace <root>
|
||||
|
||||
internal final class Flower : jet.Any {
|
||||
public final /*constructor*/ fun <init>(): Flower
|
||||
internal final var minusOne: jet.Int
|
||||
}
|
||||
@@ -1,6 +0,0 @@
|
||||
namespace <root>
|
||||
|
||||
internal final class CustomGetVal : jet.Any {
|
||||
public final /*constructor*/ fun <init>(): CustomGetVal
|
||||
internal final val zz: jet.Int
|
||||
}
|
||||
@@ -1,7 +0,0 @@
|
||||
namespace <root>
|
||||
|
||||
// <namespace name="customGetValGlobal">
|
||||
namespace customGetValGlobal
|
||||
|
||||
internal final val zz: jet.Int
|
||||
// </namespace name="customGetValGlobal">
|
||||
@@ -1,6 +0,0 @@
|
||||
namespace <root>
|
||||
|
||||
internal final class Raise : jet.Any {
|
||||
public final /*constructor*/ fun <init>(): Raise
|
||||
internal final var zz: jet.Int
|
||||
}
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user