FIR: Make FIR rendering more kotlin-styled
This commit is contained in:
@@ -9,7 +9,7 @@ FILE: complexTypes.kt
|
||||
|
||||
}
|
||||
public? final? interface Test {
|
||||
public? final? property x(val): a.b.C<out CharSequence, *>.D<in List<*>, *>
|
||||
public? final? val x: a.b.C<out CharSequence, *>.D<in List<*>, *>
|
||||
public? get(): a.b.C<out CharSequence, *>.D<in List<*>, *>
|
||||
|
||||
}
|
||||
|
||||
@@ -2,7 +2,7 @@ FILE: derivedClass.kt
|
||||
<T> public? open class Base {
|
||||
public? constructor(x: T): super<kotlin/Any>()
|
||||
|
||||
public? final? property x(val): T
|
||||
public? final? val x: T
|
||||
public? get(): T
|
||||
|
||||
}
|
||||
@@ -10,6 +10,6 @@ FILE: derivedClass.kt
|
||||
public? constructor(x: T): super<Base<T>>(x#)
|
||||
|
||||
}
|
||||
<T : Any> public? final? function create(x: T): Derived<T> {
|
||||
return@@@create Derived#(x#)
|
||||
<T : Any> public? final? fun create(x: T): Derived<T> {
|
||||
^create Derived#(x#)
|
||||
}
|
||||
|
||||
@@ -21,16 +21,16 @@ FILE: enums.kt
|
||||
public? final? enum class Planet {
|
||||
public? constructor(m: Double, r: Double): super<kotlin/Enum>()
|
||||
|
||||
public? final? property m(val): Double
|
||||
public? final? val m: Double
|
||||
public? get(): Double
|
||||
|
||||
internal final? property r(val): Double
|
||||
internal final? val r: Double
|
||||
internal get(): Double
|
||||
|
||||
public? final enum entry MERCURY : Planet {
|
||||
public? constructor(): super<Planet>(Double(1.0), Double(2.0))
|
||||
|
||||
public? open? override function sayHello(): kotlin/Unit {
|
||||
public? open? override fun sayHello(): kotlin/Unit {
|
||||
println#(String(Hello!!!))
|
||||
}
|
||||
|
||||
@@ -39,7 +39,7 @@ FILE: enums.kt
|
||||
public? final enum entry VENERA : Planet {
|
||||
public? constructor(): super<Planet>(Double(3.0), Double(4.0))
|
||||
|
||||
public? open? override function sayHello(): kotlin/Unit {
|
||||
public? open? override fun sayHello(): kotlin/Unit {
|
||||
println#(String(Ola!!!))
|
||||
}
|
||||
|
||||
@@ -48,21 +48,21 @@ FILE: enums.kt
|
||||
public? final enum entry EARTH : Planet {
|
||||
public? constructor(): super<Planet>(Double(5.0), Double(6.0))
|
||||
|
||||
public? open? override function sayHello(): kotlin/Unit {
|
||||
public? open? override fun sayHello(): kotlin/Unit {
|
||||
println#(String(Privet!!!))
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
public? final? property g(val): Double = div#(times#(G#, m#), times#(r#, r#))
|
||||
public? final? val g: Double = div#(times#(G#, m#), times#(r#, r#))
|
||||
public? get(): Double
|
||||
|
||||
public? abstract function sayHello(): kotlin/Unit
|
||||
public? abstract fun sayHello(): kotlin/Unit
|
||||
|
||||
public? final? companion object Companion {
|
||||
public? constructor(): super<kotlin/Any>()
|
||||
|
||||
public? final? const property G(val): <implicit> = Double(6.67E-11)
|
||||
public? final? const val G: <implicit> = Double(6.67E-11)
|
||||
public? get(): <implicit>
|
||||
|
||||
}
|
||||
|
||||
@@ -12,14 +12,14 @@ FILE: enums2.kt
|
||||
public? final? enum class SomeEnum {
|
||||
public? constructor(x: Some): super<kotlin/Enum>()
|
||||
|
||||
public? final? property x(val): Some
|
||||
public? final? val x: Some
|
||||
public? get(): Some
|
||||
|
||||
public? final enum entry FIRST : SomeEnum {
|
||||
public? constructor(): super<SomeEnum>(O1#)
|
||||
|
||||
public? open? override function check(y: Some): Boolean {
|
||||
return@@@check Boolean(true)
|
||||
public? open? override fun check(y: Some): Boolean {
|
||||
^check Boolean(true)
|
||||
}
|
||||
|
||||
}
|
||||
@@ -27,12 +27,12 @@ FILE: enums2.kt
|
||||
public? final enum entry SECOND : SomeEnum {
|
||||
public? constructor(): super<SomeEnum>(O2#)
|
||||
|
||||
public? open? override function check(y: Some): Boolean {
|
||||
return@@@check ==(y#, O2#)
|
||||
public? open? override fun check(y: Some): Boolean {
|
||||
^check ==(y#, O2#)
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
public? abstract function check(y: Some): Boolean
|
||||
public? abstract fun check(y: Some): Boolean
|
||||
|
||||
}
|
||||
|
||||
@@ -3,15 +3,15 @@ FILE: expectActual.kt
|
||||
public? constructor(): super<kotlin/Any>()
|
||||
|
||||
}
|
||||
public? final? expect function foo(): String
|
||||
public? final? expect property x(val): Int
|
||||
public? final? expect fun foo(): String
|
||||
public? final? expect val x: Int
|
||||
public? get(): Int
|
||||
public? final? actual class MyClass {
|
||||
public? constructor(): super<kotlin/Any>()
|
||||
|
||||
}
|
||||
public? final? actual function foo(): <implicit> {
|
||||
return@@@foo String(Hello)
|
||||
public? final? actual fun foo(): <implicit> {
|
||||
^foo String(Hello)
|
||||
}
|
||||
public? final? actual property x(val): <implicit> = Int(42)
|
||||
public? final? actual val x: <implicit> = Int(42)
|
||||
public? get(): <implicit>
|
||||
|
||||
@@ -1,9 +1,9 @@
|
||||
FILE: functionTypes.kt
|
||||
<T> public? final? function simpleRun(f: ( (T) -> Unit )): Unit {
|
||||
return@@@simpleRun f#()
|
||||
<T> public? final? fun simpleRun(f: ( (T) -> Unit )): Unit {
|
||||
^simpleRun f#()
|
||||
}
|
||||
<T, R> public? final? function simpleMap List<T>.(f: ( (T) -> R )): R {
|
||||
<T, R> public? final? fun List<T>.simpleMap(f: ( (T) -> R )): R {
|
||||
}
|
||||
<T> public? final? function simpleWith(t: T, f: ( T.() -> Unit )): Unit {
|
||||
return@@@simpleWith t#.f#()
|
||||
<T> public? final? fun simpleWith(t: T, f: ( T.() -> Unit )): Unit {
|
||||
^simpleWith t#.f#()
|
||||
}
|
||||
|
||||
@@ -1,12 +1,12 @@
|
||||
FILE: genericFunctions.kt
|
||||
public? final? interface Any {
|
||||
}
|
||||
<reified T : Any> public? final? inline function safeAs Any.(): T? {
|
||||
return@@@safeAs as?/T(this#)
|
||||
<reified T : Any> public? final? inline fun Any.safeAs(): T? {
|
||||
^safeAs as?/T(this#)
|
||||
}
|
||||
public? abstract class Summator {
|
||||
public? constructor(): super<kotlin/Any>()
|
||||
|
||||
<T> public? abstract function plus(first: T, second: T): T
|
||||
<T> public? abstract fun plus(first: T, second: T): T
|
||||
|
||||
}
|
||||
|
||||
@@ -2,7 +2,7 @@ FILE: nestedClass.kt
|
||||
public? abstract class Base {
|
||||
public? constructor(s: String): super<kotlin/Any>()
|
||||
|
||||
public? final? property s(val): String
|
||||
public? final? val s: String
|
||||
public? get(): String
|
||||
|
||||
}
|
||||
|
||||
+1
-1
@@ -1,6 +1,6 @@
|
||||
FILE: noPrimaryConstructor.kt
|
||||
public? final? class NoPrimary {
|
||||
public? final? property x(val): String
|
||||
public? final? val x: String
|
||||
public? get(): String
|
||||
|
||||
public? constructor(x: String): super<kotlin/Any>() {
|
||||
|
||||
@@ -1,29 +1,29 @@
|
||||
FILE: simpleClass.kt
|
||||
public? final? interface SomeInterface {
|
||||
public? final? function foo(x: Int, y: String): String
|
||||
public? final? fun foo(x: Int, y: String): String
|
||||
|
||||
public? final? property bar(val): Boolean
|
||||
public? final? val bar: Boolean
|
||||
public? get(): Boolean
|
||||
|
||||
}
|
||||
public? final? class SomeClass : SomeInterface {
|
||||
public? constructor(): super<kotlin/Any>()
|
||||
|
||||
private final? property baz(val): <implicit> = Int(42)
|
||||
private final? val baz: <implicit> = Int(42)
|
||||
private get(): <implicit>
|
||||
|
||||
public? open? override function foo(x: Int, y: String): String {
|
||||
return@@@foo plus#(plus#(y#, x#), baz#)
|
||||
public? open? override fun foo(x: Int, y: String): String {
|
||||
^foo plus#(plus#(y#, x#), baz#)
|
||||
}
|
||||
|
||||
public? open? override property bar(var): Boolean
|
||||
public? open? override var bar: Boolean
|
||||
public? get(): Boolean {
|
||||
return Boolean(true)
|
||||
^ Boolean(true)
|
||||
}
|
||||
public? set(value: Boolean): kotlin/Unit {
|
||||
}
|
||||
|
||||
public? final? lateinit property fau(var): Double
|
||||
public? final? lateinit var fau: Double
|
||||
public? get(): Double
|
||||
public? set(value: Double): kotlin/Unit
|
||||
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
FILE: simpleFun.kt
|
||||
public? final? function foo(): kotlin/Unit {
|
||||
public? final? fun foo(): kotlin/Unit {
|
||||
}
|
||||
public? final? suspend function bar(): kotlin/Unit {
|
||||
public? final? suspend fun bar(): kotlin/Unit {
|
||||
}
|
||||
|
||||
+4
-4
@@ -9,15 +9,15 @@ FILE: typeParameterVsNested.kt
|
||||
|
||||
}
|
||||
|
||||
public? abstract property x(val): T
|
||||
public? abstract val x: T
|
||||
public? get(): T
|
||||
|
||||
public? abstract function foo(arg: T): kotlin/Unit
|
||||
public? abstract fun foo(arg: T): kotlin/Unit
|
||||
|
||||
public? abstract property y(val): My.T
|
||||
public? abstract val y: My.T
|
||||
public? get(): My.T
|
||||
|
||||
public? abstract property z(val): test.My.T
|
||||
public? abstract val z: test.My.T
|
||||
public? get(): test.My.T
|
||||
|
||||
public? final? class Some : T {
|
||||
|
||||
@@ -1,8 +1,8 @@
|
||||
FILE: typeParameters.kt
|
||||
<out T : Any> public? final? interface List {
|
||||
public? final? operator function get(index: Int): T
|
||||
public? final? operator fun get(index: Int): T
|
||||
|
||||
public? final? infix function concat(other: List<T>): List<T>
|
||||
public? final? infix fun concat(other: List<T>): List<T>
|
||||
|
||||
}
|
||||
public? final typealias StringList = List<out String>
|
||||
@@ -14,12 +14,12 @@ FILE: typeParameters.kt
|
||||
public? final? class SomeList : AbstractList<Int> {
|
||||
public? constructor(): super<AbstractList<Int>>()
|
||||
|
||||
public? open? override function get(index: Int): Int {
|
||||
return@@@get Int(42)
|
||||
public? open? override fun get(index: Int): Int {
|
||||
^get Int(42)
|
||||
}
|
||||
|
||||
public? open? override function concat(other: List<Int>): List<Int> {
|
||||
return@@@concat this#
|
||||
public? open? override fun concat(other: List<Int>): List<Int> {
|
||||
^concat this#
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@@ -3,10 +3,10 @@ FILE: annotated.kt
|
||||
public? constructor(): super<kotlin/Any>()
|
||||
|
||||
}
|
||||
public? final? function foo(arg: Int): Int {
|
||||
public? final? fun foo(arg: Int): Int {
|
||||
when () {
|
||||
==(@Ann() arg#, Int(0)) -> {
|
||||
@Ann() return@@@foo Int(1)
|
||||
@Ann() ^foo Int(1)
|
||||
}
|
||||
else -> {
|
||||
}
|
||||
@@ -14,20 +14,20 @@ FILE: annotated.kt
|
||||
|
||||
@Ann() when () {
|
||||
==(arg#, Int(1)) -> {
|
||||
return@@@foo @Ann() Int(1)
|
||||
^foo @Ann() Int(1)
|
||||
}
|
||||
else -> {
|
||||
}
|
||||
}
|
||||
|
||||
return@@@foo Int(42)
|
||||
^foo Int(42)
|
||||
}
|
||||
public? final? data class Two {
|
||||
public? constructor(x: Int, y: Int): super<kotlin/Any>()
|
||||
|
||||
}
|
||||
public? final? function bar(two: Two): kotlin/Unit {
|
||||
val <destruct>: <implicit> = two#
|
||||
@Ann() val x: <implicit> = component1(<destruct>#)
|
||||
@Ann() val y: <implicit> = component2(<destruct>#)
|
||||
public? final? fun bar(two: Two): kotlin/Unit {
|
||||
lval <destruct>: <implicit> = two#
|
||||
@Ann() lval x: <implicit> = component1(<destruct>#)
|
||||
@Ann() lval y: <implicit> = component2(<destruct>#)
|
||||
}
|
||||
|
||||
@@ -1,16 +1,16 @@
|
||||
FILE: arrayAccess.kt
|
||||
public? final? property p(val): <implicit> = Int(0)
|
||||
public? final? val p: <implicit> = Int(0)
|
||||
public? get(): <implicit>
|
||||
public? final? function foo(): <implicit> {
|
||||
return@@@foo Int(1)
|
||||
public? final? fun foo(): <implicit> {
|
||||
^foo Int(1)
|
||||
}
|
||||
public? final? class Wrapper {
|
||||
public? constructor(v: IntArray): super<kotlin/Any>()
|
||||
|
||||
public? final? property v(val): IntArray
|
||||
public? final? val v: IntArray
|
||||
public? get(): IntArray
|
||||
|
||||
}
|
||||
public? final? function test(a: IntArray, w: Wrapper): <implicit> {
|
||||
return@@@test plus#(plus#(plus#(a#[Int(0)], a#[p#]), a#[foo#()]), w#.v#[Int(0)])
|
||||
public? final? fun test(a: IntArray, w: Wrapper): <implicit> {
|
||||
^test plus#(plus#(plus#(a#[Int(0)], a#[p#]), a#[foo#()]), w#.v#[Int(0)])
|
||||
}
|
||||
|
||||
@@ -1,12 +1,12 @@
|
||||
FILE: arrayAssignment.kt
|
||||
public? final? function test(): kotlin/Unit {
|
||||
val x: <implicit> = intArrayOf#(Int(1), Int(2), Int(3))
|
||||
public? final? fun test(): kotlin/Unit {
|
||||
lval x: <implicit> = intArrayOf#(Int(1), Int(2), Int(3))
|
||||
x#[Int(1)] = Int(0)
|
||||
}
|
||||
public? final? function foo(): <implicit> {
|
||||
return@@@foo Int(1)
|
||||
public? final? fun foo(): <implicit> {
|
||||
^foo Int(1)
|
||||
}
|
||||
public? final? function test2(): kotlin/Unit {
|
||||
val <array-set>: <implicit> = intArrayOf#(Int(1), Int(2), Int(3))
|
||||
public? final? fun test2(): kotlin/Unit {
|
||||
lval <array-set>: <implicit> = intArrayOf#(Int(1), Int(2), Int(3))
|
||||
<array-set>#[foo#()] = Int(1)
|
||||
}
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
FILE: branches.kt
|
||||
public? final? function foo(a: Int, b: Int): <implicit> {
|
||||
return@@@foo when () {
|
||||
public? final? fun foo(a: Int, b: Int): <implicit> {
|
||||
^foo when () {
|
||||
>(a#, b#) -> {
|
||||
a#
|
||||
}
|
||||
@@ -10,33 +10,33 @@ FILE: branches.kt
|
||||
}
|
||||
|
||||
}
|
||||
public? final? function bar(a: Double, b: Double): Double {
|
||||
public? final? fun bar(a: Double, b: Double): Double {
|
||||
when () {
|
||||
>(a#, b#) -> {
|
||||
println#(a#)
|
||||
return@@@bar a#
|
||||
^bar a#
|
||||
}
|
||||
else -> {
|
||||
println#(b#)
|
||||
return@@@bar b#
|
||||
^bar b#
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
public? final? function baz(a: Long, b: Long): Long {
|
||||
public? final? fun baz(a: Long, b: Long): Long {
|
||||
when () {
|
||||
>(a#, b#) -> {
|
||||
println#(a#)
|
||||
return@@@baz a#
|
||||
^baz a#
|
||||
}
|
||||
else -> {
|
||||
return@@@baz b#
|
||||
^baz b#
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
public? final? function grade(g: Int): String {
|
||||
return@@@grade when (g#) {
|
||||
public? final? fun grade(g: Int): String {
|
||||
^grade when (g#) {
|
||||
||(==($subj$, Int(6)), ==($subj$, Int(7))) -> {
|
||||
String(Outstanding)
|
||||
}
|
||||
|
||||
+11
-11
@@ -2,28 +2,28 @@ FILE: callableReferences.kt
|
||||
public? final? class A {
|
||||
public? constructor(): super<kotlin/Any>()
|
||||
|
||||
public? final? function foo(): kotlin/Unit {
|
||||
public? final? fun foo(): kotlin/Unit {
|
||||
}
|
||||
|
||||
public? final? property bar(val): <implicit> = Int(0)
|
||||
public? final? val bar: <implicit> = Int(0)
|
||||
public? get(): <implicit>
|
||||
|
||||
}
|
||||
public? final? function qux A.(): kotlin/Unit {
|
||||
public? final? fun A.qux(): kotlin/Unit {
|
||||
}
|
||||
public? final? function baz(): kotlin/Unit {
|
||||
public? final? fun baz(): kotlin/Unit {
|
||||
}
|
||||
public? final? property test1(val): <implicit> = A#()::foo#
|
||||
public? final? val test1: <implicit> = A#()::foo#
|
||||
public? get(): <implicit>
|
||||
public? final? property test2(val): <implicit> = A#()::bar#
|
||||
public? final? val test2: <implicit> = A#()::bar#
|
||||
public? get(): <implicit>
|
||||
public? final? property test3(val): <implicit> = A#()::qux#
|
||||
public? final? val test3: <implicit> = A#()::qux#
|
||||
public? get(): <implicit>
|
||||
public? final? property test4(val): <implicit> = A#::foo#
|
||||
public? final? val test4: <implicit> = A#::foo#
|
||||
public? get(): <implicit>
|
||||
public? final? property test5(val): <implicit> = A#::bar#
|
||||
public? final? val test5: <implicit> = A#::bar#
|
||||
public? get(): <implicit>
|
||||
public? final? property test6(val): <implicit> = A#::qux#
|
||||
public? final? val test6: <implicit> = A#::qux#
|
||||
public? get(): <implicit>
|
||||
public? final? property test7(val): <implicit> = ::baz#
|
||||
public? final? val test7: <implicit> = ::baz#
|
||||
public? get(): <implicit>
|
||||
|
||||
+15
-15
@@ -1,36 +1,36 @@
|
||||
FILE: calls.kt
|
||||
public? final? infix function distance(x: Int, y: Int): <implicit> {
|
||||
return@@@distance plus#(x#, y#)
|
||||
public? final? infix fun distance(x: Int, y: Int): <implicit> {
|
||||
^distance plus#(x#, y#)
|
||||
}
|
||||
public? final? function test(): Int {
|
||||
return@@@test distance#(Int(3), Int(4))
|
||||
public? final? fun test(): Int {
|
||||
^test distance#(Int(3), Int(4))
|
||||
}
|
||||
public? final? function testRegular(): Int {
|
||||
return@@@testRegular distance#(Int(3), Int(4))
|
||||
public? final? fun testRegular(): Int {
|
||||
^testRegular distance#(Int(3), Int(4))
|
||||
}
|
||||
public? final? class My {
|
||||
public? constructor(x: Int): super<kotlin/Any>()
|
||||
|
||||
public? final? property x(var): Int
|
||||
public? final? var x: Int
|
||||
public? get(): Int
|
||||
public? set(value: Int): kotlin/Unit
|
||||
|
||||
public? final? operator function invoke(): <implicit> {
|
||||
return@@@invoke x#
|
||||
public? final? operator fun invoke(): <implicit> {
|
||||
^invoke x#
|
||||
}
|
||||
|
||||
public? final? function foo(): kotlin/Unit {
|
||||
public? final? fun foo(): kotlin/Unit {
|
||||
}
|
||||
|
||||
public? final? function copy(): <implicit> {
|
||||
return@@@copy My#(x#)
|
||||
public? final? fun copy(): <implicit> {
|
||||
^copy My#(x#)
|
||||
}
|
||||
|
||||
}
|
||||
public? final? function testInvoke(): Int {
|
||||
return@@@testInvoke invoke#(My#(Int(13)))
|
||||
public? final? fun testInvoke(): Int {
|
||||
^testInvoke invoke#(My#(Int(13)))
|
||||
}
|
||||
public? final? function testQualified(first: My, second: My?): kotlin/Unit {
|
||||
public? final? fun testQualified(first: My, second: My?): kotlin/Unit {
|
||||
println#(first#.x#)
|
||||
println#(second#?.x#)
|
||||
first#.foo#()
|
||||
|
||||
@@ -3,7 +3,7 @@ FILE: classReference.kt
|
||||
public? constructor(): super<kotlin/Any>()
|
||||
|
||||
}
|
||||
public? final? function test(): kotlin/Unit {
|
||||
public? final? fun test(): kotlin/Unit {
|
||||
<getClass>(A#)
|
||||
<getClass>(test#.A#)
|
||||
<getClass>(A#())
|
||||
|
||||
+3
-3
@@ -2,21 +2,21 @@ FILE: collectionLiterals.kt
|
||||
public? final? annotation class Ann1 {
|
||||
public? constructor(arr: IntArray): super<kotlin/Any>()
|
||||
|
||||
public? final? property arr(val): IntArray
|
||||
public? final? val arr: IntArray
|
||||
public? get(): IntArray
|
||||
|
||||
}
|
||||
public? final? annotation class Ann2 {
|
||||
public? constructor(arr: DoubleArray): super<kotlin/Any>()
|
||||
|
||||
public? final? property arr(val): DoubleArray
|
||||
public? final? val arr: DoubleArray
|
||||
public? get(): DoubleArray
|
||||
|
||||
}
|
||||
public? final? annotation class Ann3 {
|
||||
public? constructor(arr: Array<String>): super<kotlin/Any>()
|
||||
|
||||
public? final? property arr(val): Array<String>
|
||||
public? final? val arr: Array<String>
|
||||
public? get(): Array<String>
|
||||
|
||||
}
|
||||
|
||||
@@ -2,22 +2,22 @@ FILE: destructuring.kt
|
||||
public? final? data class Some {
|
||||
public? constructor(first: Int, second: Double, third: String): super<kotlin/Any>()
|
||||
|
||||
public? final? property first(val): Int
|
||||
public? final? val first: Int
|
||||
public? get(): Int
|
||||
|
||||
public? final? property second(val): Double
|
||||
public? final? val second: Double
|
||||
public? get(): Double
|
||||
|
||||
public? final? property third(val): String
|
||||
public? final? val third: String
|
||||
public? get(): String
|
||||
|
||||
}
|
||||
public? final? function foo(some: Some): kotlin/Unit {
|
||||
val <destruct>: <implicit> = some#
|
||||
var x: <implicit> = component1(<destruct>#)
|
||||
var y: <implicit> = component2(<destruct>#)
|
||||
var z: String = component3(<destruct>#)
|
||||
val <unary>: <implicit> = x#
|
||||
public? final? fun foo(some: Some): kotlin/Unit {
|
||||
lval <destruct>: <implicit> = some#
|
||||
lvar x: <implicit> = component1(<destruct>#)
|
||||
lvar y: <implicit> = component2(<destruct>#)
|
||||
lvar z: String = component3(<destruct>#)
|
||||
lval <unary>: <implicit> = x#
|
||||
x# = inc#(<unary>#)
|
||||
<unary>#
|
||||
y# *= Double(2.0)
|
||||
|
||||
+19
-19
@@ -1,25 +1,25 @@
|
||||
FILE: for.kt
|
||||
public? final? function foo(): kotlin/Unit {
|
||||
val <range>: <implicit> = rangeTo#(Int(1), Int(10))
|
||||
val <iterator>: <implicit> = <range>#.iterator#()
|
||||
public? final? fun foo(): kotlin/Unit {
|
||||
lval <range>: <implicit> = rangeTo#(Int(1), Int(10))
|
||||
lval <iterator>: <implicit> = <range>#.iterator#()
|
||||
while(<iterator>#.hasNext#()) {
|
||||
val i: <implicit> = <iterator>#.next#()
|
||||
lval i: <implicit> = <iterator>#.next#()
|
||||
println#(i#)
|
||||
}
|
||||
|
||||
}
|
||||
public? final? function bar(list: List<String>): kotlin/Unit {
|
||||
val <range>: <implicit> = list#.subList#(Int(0), Int(10))
|
||||
val <iterator>: <implicit> = <range>#.iterator#()
|
||||
public? final? fun bar(list: List<String>): kotlin/Unit {
|
||||
lval <range>: <implicit> = list#.subList#(Int(0), Int(10))
|
||||
lval <iterator>: <implicit> = <range>#.iterator#()
|
||||
while(<iterator>#.hasNext#()) {
|
||||
val element: <implicit> = <iterator>#.next#()
|
||||
lval element: <implicit> = <iterator>#.next#()
|
||||
println#(element#)
|
||||
}
|
||||
|
||||
val <range>: <implicit> = list#.subList#(Int(10), Int(20))
|
||||
val <iterator>: <implicit> = <range>#.iterator#()
|
||||
lval <range>: <implicit> = list#.subList#(Int(10), Int(20))
|
||||
lval <iterator>: <implicit> = <range>#.iterator#()
|
||||
while(<iterator>#.hasNext#()) {
|
||||
val element: <implicit> = <iterator>#.next#()
|
||||
lval element: <implicit> = <iterator>#.next#()
|
||||
println#(element#)
|
||||
}
|
||||
|
||||
@@ -27,20 +27,20 @@ FILE: for.kt
|
||||
public? final? data class Some {
|
||||
public? constructor(x: Int, y: Int): super<kotlin/Any>()
|
||||
|
||||
public? final? property x(val): Int
|
||||
public? final? val x: Int
|
||||
public? get(): Int
|
||||
|
||||
public? final? property y(val): Int
|
||||
public? final? val y: Int
|
||||
public? get(): Int
|
||||
|
||||
}
|
||||
public? final? function baz(set: Set<Some>): kotlin/Unit {
|
||||
val <range>: <implicit> = set#
|
||||
val <iterator>: <implicit> = <range>#.iterator#()
|
||||
public? final? fun baz(set: Set<Some>): kotlin/Unit {
|
||||
lval <range>: <implicit> = set#
|
||||
lval <iterator>: <implicit> = <range>#.iterator#()
|
||||
while(<iterator>#.hasNext#()) {
|
||||
val <destruct>: <implicit> = <iterator>#.next#()
|
||||
val x: <implicit> = component1(<destruct>#)
|
||||
val y: <implicit> = component2(<destruct>#)
|
||||
lval <destruct>: <implicit> = <iterator>#.next#()
|
||||
lval x: <implicit> = component1(<destruct>#)
|
||||
lval y: <implicit> = component2(<destruct>#)
|
||||
println#(plus#(String(x = ), x#, String( y = ), y#))
|
||||
}
|
||||
|
||||
|
||||
@@ -1,9 +1,9 @@
|
||||
FILE: genericCalls.kt
|
||||
<T> public? final? function nullableValue(): T? {
|
||||
return@@@nullableValue Null(null)
|
||||
<T> public? final? fun nullableValue(): T? {
|
||||
^nullableValue Null(null)
|
||||
}
|
||||
public? final? function test(): kotlin/Unit {
|
||||
val n: <implicit> = nullableValue#<Int>()
|
||||
val x: <implicit> = nullableValue#<Double>()
|
||||
val s: <implicit> = nullableValue#<String>()
|
||||
public? final? fun test(): kotlin/Unit {
|
||||
lval n: <implicit> = nullableValue#<Int>()
|
||||
lval x: <implicit> = nullableValue#<Double>()
|
||||
lval s: <implicit> = nullableValue#<String>()
|
||||
}
|
||||
|
||||
@@ -2,7 +2,7 @@ FILE: init.kt
|
||||
public? final? class WithInit {
|
||||
public? constructor(x: Int): super<kotlin/Any>()
|
||||
|
||||
public? final? property x(val): Int
|
||||
public? final? val x: Int
|
||||
public? get(): Int
|
||||
|
||||
init {
|
||||
|
||||
+28
-28
@@ -2,74 +2,74 @@ FILE: lambda.kt
|
||||
public? final? data class Tuple {
|
||||
public? constructor(x: Int, y: Int): super<kotlin/Any>()
|
||||
|
||||
public? final? property x(val): Int
|
||||
public? final? val x: Int
|
||||
public? get(): Int
|
||||
|
||||
public? final? property y(val): Int
|
||||
public? final? val y: Int
|
||||
public? get(): Int
|
||||
|
||||
}
|
||||
public? final? inline function use(f: ( (Tuple) -> Int )): <implicit> {
|
||||
return@@@use f#(Tuple#(Int(1), Int(2)))
|
||||
public? final? inline fun use(f: ( (Tuple) -> Int )): <implicit> {
|
||||
^use f#(Tuple#(Int(1), Int(2)))
|
||||
}
|
||||
public? final? function foo(): Int {
|
||||
val l1: <implicit> = function <implicit>.<anonymous>(t: Tuple): <implicit> {
|
||||
return {
|
||||
val x: <implicit> = t#.x#
|
||||
val y: <implicit> = t#.y#
|
||||
public? final? fun foo(): Int {
|
||||
lval l1: <implicit> = fun <implicit>.<anonymous>(t: Tuple): <implicit> {
|
||||
^ {
|
||||
lval x: <implicit> = t#.x#
|
||||
lval y: <implicit> = t#.y#
|
||||
plus#(x#, y#)
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
use#(use@function <implicit>.<anonymous>(<destruct>: <implicit>): <implicit> {
|
||||
return {
|
||||
val x: <implicit> = component1(<destruct>#)
|
||||
val y: <implicit> = component2(<destruct>#)
|
||||
use#(use@fun <implicit>.<anonymous>(<destruct>: <implicit>): <implicit> {
|
||||
^ {
|
||||
lval x: <implicit> = component1(<destruct>#)
|
||||
lval y: <implicit> = component2(<destruct>#)
|
||||
plus#(x#, y#)
|
||||
}
|
||||
|
||||
}
|
||||
)
|
||||
return@@@foo use#(use@function <implicit>.<anonymous>(): <implicit> {
|
||||
return {
|
||||
^foo use#(use@fun <implicit>.<anonymous>(): <implicit> {
|
||||
^ {
|
||||
when () {
|
||||
==(it#.x#, Int(0)) -> {
|
||||
return@@@foo Int(0)
|
||||
^foo Int(0)
|
||||
}
|
||||
else -> {
|
||||
}
|
||||
}
|
||||
|
||||
return@@@use it#.y#
|
||||
^@use it#.y#
|
||||
}
|
||||
|
||||
}
|
||||
)
|
||||
}
|
||||
public? final? function bar(): Int {
|
||||
return@@@bar use#(lambda@function <implicit>.<anonymous>(): <implicit> {
|
||||
return {
|
||||
public? final? fun bar(): Int {
|
||||
^bar use#(lambda@fun <implicit>.<anonymous>(): <implicit> {
|
||||
^ {
|
||||
when () {
|
||||
==(it#.x#, Int(0)) -> {
|
||||
return@@@bar Int(0)
|
||||
^bar Int(0)
|
||||
}
|
||||
else -> {
|
||||
}
|
||||
}
|
||||
|
||||
return@@@lambda it#.y#
|
||||
^@lambda it#.y#
|
||||
}
|
||||
|
||||
}
|
||||
)
|
||||
}
|
||||
public? final? function test(list: List<Int>): kotlin/Unit {
|
||||
val map: <implicit> = mutableMapOf#<Int, String>()
|
||||
list#.forEach#(forEach@function <implicit>.<anonymous>(): <implicit> {
|
||||
return {
|
||||
val <complex-set>: <implicit> = map#.getOrPut#(it#, getOrPut@function <implicit>.<anonymous>(): <implicit> {
|
||||
return {
|
||||
public? final? fun test(list: List<Int>): kotlin/Unit {
|
||||
lval map: <implicit> = mutableMapOf#<Int, String>()
|
||||
list#.forEach#(forEach@fun <implicit>.<anonymous>(): <implicit> {
|
||||
^ {
|
||||
lval <complex-set>: <implicit> = map#.getOrPut#(it#, getOrPut@fun <implicit>.<anonymous>(): <implicit> {
|
||||
^ {
|
||||
mutableListOf#()
|
||||
}
|
||||
|
||||
|
||||
+12
-12
@@ -1,33 +1,33 @@
|
||||
FILE: locals.kt
|
||||
public? final? function withLocals(p: Int): Int {
|
||||
public? final? fun withLocals(p: Int): Int {
|
||||
public? final? class Local {
|
||||
public? constructor(pp: Int): super<kotlin/Any>()
|
||||
|
||||
public? final? property pp(val): Int
|
||||
public? final? val pp: Int
|
||||
public? get(): Int
|
||||
|
||||
public? final? function diff(): <implicit> {
|
||||
return@@@diff minus#(pp#, p#)
|
||||
public? final? fun diff(): <implicit> {
|
||||
^diff minus#(pp#, p#)
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
val x: <implicit> = Local#(Int(42)).diff#()
|
||||
public? final? function sum(y: Int, z: Int, f: ( (Int, Int) -> Int )): Int {
|
||||
return@@@sum plus#(x#, f#(plus#(y#, z#)))
|
||||
lval x: <implicit> = Local#(Int(42)).diff#()
|
||||
public? final? fun sum(y: Int, z: Int, f: ( (Int, Int) -> Int )): Int {
|
||||
^sum plus#(x#, f#(plus#(y#, z#)))
|
||||
}
|
||||
|
||||
val code: <implicit> = object : Any {
|
||||
lval code: <implicit> = object : Any {
|
||||
public? constructor(): super<Any>()
|
||||
|
||||
public? final? function foo(): <implicit> {
|
||||
return@@@foo hashCode#()
|
||||
public? final? fun foo(): <implicit> {
|
||||
^foo hashCode#()
|
||||
}
|
||||
|
||||
}
|
||||
.foo#()
|
||||
return@@@withLocals sum#(code#, Local#(Int(1)).diff#(), function <anonymous>(x: Int, y: Int): <implicit> {
|
||||
return plus#(x#, y#)
|
||||
^withLocals sum#(code#, Local#(Int(1)).diff#(), fun <anonymous>(x: Int, y: Int): <implicit> {
|
||||
^ plus#(x#, y#)
|
||||
}
|
||||
)
|
||||
}
|
||||
|
||||
@@ -1,16 +1,16 @@
|
||||
FILE: modifications.kt
|
||||
public? final? function simple(): kotlin/Unit {
|
||||
var x: <implicit> = Int(10)
|
||||
public? final? fun simple(): kotlin/Unit {
|
||||
lvar x: <implicit> = Int(10)
|
||||
x# += Int(20)
|
||||
x# -= Int(5)
|
||||
x# /= Int(5)
|
||||
x# *= Int(10)
|
||||
}
|
||||
public? final? function modify List<String>.(): kotlin/Unit {
|
||||
public? final? fun List<String>.modify(): kotlin/Unit {
|
||||
this# += String(Alpha)
|
||||
this# += String(Omega)
|
||||
}
|
||||
public? final? function modify Any.(): kotlin/Unit {
|
||||
val <complex-set>: <implicit> = as/List<Int>(this#)
|
||||
public? final? fun Any.modify(): kotlin/Unit {
|
||||
lval <complex-set>: <implicit> = as/List<Int>(this#)
|
||||
<complex-set># += Int(42)
|
||||
}
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
FILE: namedArgument.kt
|
||||
public? final? function foo(first: String = String(), second: Boolean = Boolean(true), third: Double = Double(3.1415)): kotlin/Unit {
|
||||
public? final? fun foo(first: String = String(), second: Boolean = Boolean(true), third: Double = Double(3.1415)): kotlin/Unit {
|
||||
}
|
||||
public? final? function test(): kotlin/Unit {
|
||||
public? final? fun test(): kotlin/Unit {
|
||||
foo#()
|
||||
foo#(String(Alpha), Boolean(false), Double(2.71))
|
||||
foo#(first = String(Hello), second = Boolean(true))
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
FILE: nullability.kt
|
||||
public? final? function orFourtyTwo(arg: Int?): <implicit> {
|
||||
return@@@orFourtyTwo when (val <elvis>: <implicit> = arg#) {
|
||||
public? final? fun orFourtyTwo(arg: Int?): <implicit> {
|
||||
^orFourtyTwo when (lval <elvis>: <implicit> = arg#) {
|
||||
!=($subj$, Null(null)) -> {
|
||||
<elvis>#
|
||||
}
|
||||
@@ -10,8 +10,8 @@ FILE: nullability.kt
|
||||
}
|
||||
|
||||
}
|
||||
public? final? function bang(arg: Int?): <implicit> {
|
||||
return@@@bang when (val <bangbang>: <implicit> = arg#) {
|
||||
public? final? fun bang(arg: Int?): <implicit> {
|
||||
^bang when (lval <bangbang>: <implicit> = arg#) {
|
||||
!=($subj$, Null(null)) -> {
|
||||
<bangbang>#
|
||||
}
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
FILE: simpleReturns.kt
|
||||
public? final? function foo(): kotlin/Unit {
|
||||
return@@@foo Unit
|
||||
public? final? fun foo(): kotlin/Unit {
|
||||
^foo Unit
|
||||
}
|
||||
public? final? function bar(): String {
|
||||
return@@@bar String(Hello)
|
||||
public? final? fun bar(): String {
|
||||
^bar String(Hello)
|
||||
}
|
||||
|
||||
@@ -1,25 +1,25 @@
|
||||
FILE: super.kt
|
||||
public? final? interface A {
|
||||
public? final? function foo(): kotlin/Unit {
|
||||
public? final? fun foo(): kotlin/Unit {
|
||||
}
|
||||
|
||||
}
|
||||
public? final? interface B {
|
||||
public? final? function foo(): kotlin/Unit {
|
||||
public? final? fun foo(): kotlin/Unit {
|
||||
}
|
||||
|
||||
public? final? function bar(): kotlin/Unit {
|
||||
public? final? fun bar(): kotlin/Unit {
|
||||
}
|
||||
|
||||
}
|
||||
public? final? class C : A, B {
|
||||
public? constructor(): super<kotlin/Any>()
|
||||
|
||||
public? open? override function bar(): kotlin/Unit {
|
||||
public? open? override fun bar(): kotlin/Unit {
|
||||
super<<implicit>>.bar#()
|
||||
}
|
||||
|
||||
public? open? override function foo(): kotlin/Unit {
|
||||
public? open? override fun foo(): kotlin/Unit {
|
||||
super<A>.foo#()
|
||||
super<B>.foo#()
|
||||
}
|
||||
|
||||
+13
-13
@@ -2,30 +2,30 @@ FILE: these.kt
|
||||
public? final? class Some {
|
||||
public? constructor(): super<kotlin/Any>()
|
||||
|
||||
public? final? function foo(): Int {
|
||||
return@@@foo Int(1)
|
||||
public? final? fun foo(): Int {
|
||||
^foo Int(1)
|
||||
}
|
||||
|
||||
public? final? function bar(): Int {
|
||||
return@@@bar this#.foo#()
|
||||
public? final? fun bar(): Int {
|
||||
^bar this#.foo#()
|
||||
}
|
||||
|
||||
public? final? property instance(val): Some
|
||||
public? final? val instance: Some
|
||||
public? get(): Some {
|
||||
return this@Some
|
||||
^ this@Some
|
||||
}
|
||||
|
||||
public? final? function extension String.(): Int {
|
||||
return@@@extension plus#(this@Some.bar#(), this#.length#)
|
||||
public? final? fun String.extension(): Int {
|
||||
^extension plus#(this@Some.bar#(), this#.length#)
|
||||
}
|
||||
|
||||
}
|
||||
public? final? function extension Some.(): <implicit> {
|
||||
return@@@extension this#.bar#()
|
||||
public? final? fun Some.extension(): <implicit> {
|
||||
^extension this#.bar#()
|
||||
}
|
||||
public? final? function test(some: Some): Int {
|
||||
return@@@test with#(some#, with@function <implicit>.<anonymous>(): <implicit> {
|
||||
return {
|
||||
public? final? fun test(some: Some): Int {
|
||||
^test with#(some#, with@fun <implicit>.<anonymous>(): <implicit> {
|
||||
^ {
|
||||
plus#(this#.foo#(), this@with.extension#())
|
||||
}
|
||||
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
FILE: try.kt
|
||||
public? final? function some(): kotlin/Unit {
|
||||
public? final? fun some(): kotlin/Unit {
|
||||
try {
|
||||
throw KotlinNullPointerException#()
|
||||
}
|
||||
|
||||
@@ -1,15 +1,15 @@
|
||||
FILE: typeOperators.kt
|
||||
public? final? interface IThing {
|
||||
}
|
||||
public? final? function test1(x: Any): <implicit> {
|
||||
return@@@test1 is/IThing(x#)
|
||||
public? final? fun test1(x: Any): <implicit> {
|
||||
^test1 is/IThing(x#)
|
||||
}
|
||||
public? final? function test2(x: Any): <implicit> {
|
||||
return@@@test2 !is/IThing(x#)
|
||||
public? final? fun test2(x: Any): <implicit> {
|
||||
^test2 !is/IThing(x#)
|
||||
}
|
||||
public? final? function test3(x: Any): <implicit> {
|
||||
return@@@test3 as/IThing(x#)
|
||||
public? final? fun test3(x: Any): <implicit> {
|
||||
^test3 as/IThing(x#)
|
||||
}
|
||||
public? final? function test4(x: Any): <implicit> {
|
||||
return@@@test4 as?/IThing(x#)
|
||||
public? final? fun test4(x: Any): <implicit> {
|
||||
^test4 as?/IThing(x#)
|
||||
}
|
||||
|
||||
+32
-32
@@ -1,26 +1,26 @@
|
||||
FILE: unary.kt
|
||||
public? final? function test(): kotlin/Unit {
|
||||
var x: <implicit> = Int(0)
|
||||
val x1: <implicit> = {
|
||||
val <unary>: <implicit> = x#
|
||||
public? final? fun test(): kotlin/Unit {
|
||||
lvar x: <implicit> = Int(0)
|
||||
lval x1: <implicit> = {
|
||||
lval <unary>: <implicit> = x#
|
||||
x# = inc#(<unary>#)
|
||||
<unary>#
|
||||
}
|
||||
|
||||
val x2: <implicit> = {
|
||||
val <unary>: <implicit> = x#
|
||||
lval x2: <implicit> = {
|
||||
lval <unary>: <implicit> = x#
|
||||
x# = inc#(<unary>#)
|
||||
x#
|
||||
}
|
||||
|
||||
val x3: <implicit> = {
|
||||
val <unary>: <implicit> = x#
|
||||
lval x3: <implicit> = {
|
||||
lval <unary>: <implicit> = x#
|
||||
x# = dec#(<unary>#)
|
||||
x#
|
||||
}
|
||||
|
||||
val x4: <implicit> = {
|
||||
val <unary>: <implicit> = x#
|
||||
lval x4: <implicit> = {
|
||||
lval <unary>: <implicit> = x#
|
||||
x# = dec#(<unary>#)
|
||||
<unary>#
|
||||
}
|
||||
@@ -37,35 +37,35 @@ FILE: unary.kt
|
||||
public? final? class X {
|
||||
public? constructor(i: Int): super<kotlin/Any>()
|
||||
|
||||
public? final? property i(val): Int
|
||||
public? final? val i: Int
|
||||
public? get(): Int
|
||||
|
||||
}
|
||||
public? final? function test2(x: X): kotlin/Unit {
|
||||
val x1: <implicit> = {
|
||||
val <unary>: <implicit> = x#.i#
|
||||
public? final? fun test2(x: X): kotlin/Unit {
|
||||
lval x1: <implicit> = {
|
||||
lval <unary>: <implicit> = x#.i#
|
||||
x#.i# = inc#(<unary>#)
|
||||
<unary>#
|
||||
}
|
||||
|
||||
val x2: <implicit> = {
|
||||
val <unary>: <implicit> = x#.i#
|
||||
val <unary-result>: <implicit> = inc#(<unary>#)
|
||||
lval x2: <implicit> = {
|
||||
lval <unary>: <implicit> = x#.i#
|
||||
lval <unary-result>: <implicit> = inc#(<unary>#)
|
||||
x#.i# = <unary-result>#
|
||||
<unary-result>#
|
||||
}
|
||||
|
||||
}
|
||||
public? final? function test3(arr: Array<Int>): kotlin/Unit {
|
||||
val x1: <implicit> = {
|
||||
val <unary>: <implicit> = arr#[Int(0)]
|
||||
public? final? fun test3(arr: Array<Int>): kotlin/Unit {
|
||||
lval x1: <implicit> = {
|
||||
lval <unary>: <implicit> = arr#[Int(0)]
|
||||
arr#[Int(0)] = inc#(<unary>#)
|
||||
<unary>#
|
||||
}
|
||||
|
||||
val x2: <implicit> = {
|
||||
val <unary>: <implicit> = arr#[Int(1)]
|
||||
val <unary-result>: <implicit> = inc#(<unary>#)
|
||||
lval x2: <implicit> = {
|
||||
lval <unary>: <implicit> = arr#[Int(1)]
|
||||
lval <unary-result>: <implicit> = inc#(<unary>#)
|
||||
arr#[Int(1)] = <unary-result>#
|
||||
<unary-result>#
|
||||
}
|
||||
@@ -74,22 +74,22 @@ FILE: unary.kt
|
||||
public? final? class Y {
|
||||
public? constructor(arr: Array<Int>): super<kotlin/Any>()
|
||||
|
||||
public? final? property arr(val): Array<Int>
|
||||
public? final? val arr: Array<Int>
|
||||
public? get(): Array<Int>
|
||||
|
||||
}
|
||||
public? final? function test4(y: Y): kotlin/Unit {
|
||||
val x1: <implicit> = {
|
||||
val <unary>: <implicit> = y#.arr#[Int(0)]
|
||||
val <array-set>: <implicit> = y#.arr#
|
||||
public? final? fun test4(y: Y): kotlin/Unit {
|
||||
lval x1: <implicit> = {
|
||||
lval <unary>: <implicit> = y#.arr#[Int(0)]
|
||||
lval <array-set>: <implicit> = y#.arr#
|
||||
<array-set>#[Int(0)] = inc#(<unary>#)
|
||||
<unary>#
|
||||
}
|
||||
|
||||
val x2: <implicit> = {
|
||||
val <unary>: <implicit> = y#.arr#[Int(1)]
|
||||
val <unary-result>: <implicit> = inc#(<unary>#)
|
||||
val <array-set>: <implicit> = y#.arr#
|
||||
lval x2: <implicit> = {
|
||||
lval <unary>: <implicit> = y#.arr#[Int(1)]
|
||||
lval <unary-result>: <implicit> = inc#(<unary>#)
|
||||
lval <array-set>: <implicit> = y#.arr#
|
||||
<array-set>#[Int(1)] = <unary-result>#
|
||||
<unary-result>#
|
||||
}
|
||||
|
||||
@@ -1,9 +1,9 @@
|
||||
FILE: variables.kt
|
||||
public? final? function foo(): kotlin/Unit {
|
||||
val x: <implicit> = Int(1)
|
||||
var y: <implicit> = plus#(x#, Int(1))
|
||||
val z: <implicit> = times#(y#, Int(2))
|
||||
public? final? fun foo(): kotlin/Unit {
|
||||
lval x: <implicit> = Int(1)
|
||||
lvar y: <implicit> = plus#(x#, Int(1))
|
||||
lval z: <implicit> = times#(y#, Int(2))
|
||||
y# = plus#(y#, z#)
|
||||
val w: <implicit> = minus#(y#, x#)
|
||||
return@@@foo w#
|
||||
lval w: <implicit> = minus#(y#, x#)
|
||||
^foo w#
|
||||
}
|
||||
|
||||
@@ -1,13 +1,13 @@
|
||||
FILE: while.kt
|
||||
public? final? function foo(limit: Int): kotlin/Unit {
|
||||
var k: <implicit> = Int(0)
|
||||
public? final? fun foo(limit: Int): kotlin/Unit {
|
||||
lvar k: <implicit> = Int(0)
|
||||
some@while(<(k#, limit#)) {
|
||||
val <unary>: <implicit> = k#
|
||||
lval <unary>: <implicit> = k#
|
||||
k# = inc#(<unary>#)
|
||||
<unary>#
|
||||
println#(k#)
|
||||
while(==(k#, Int(13))) {
|
||||
val <unary>: <implicit> = k#
|
||||
lval <unary>: <implicit> = k#
|
||||
k# = inc#(<unary>#)
|
||||
<unary>#
|
||||
when () {
|
||||
@@ -31,10 +31,10 @@ FILE: while.kt
|
||||
}
|
||||
|
||||
}
|
||||
public? final? function bar(limit: Int): kotlin/Unit {
|
||||
var k: <implicit> = limit#
|
||||
public? final? fun bar(limit: Int): kotlin/Unit {
|
||||
lvar k: <implicit> = limit#
|
||||
do {
|
||||
val <unary>: <implicit> = k#
|
||||
lval <unary>: <implicit> = k#
|
||||
k# = dec#(<unary>#)
|
||||
<unary>#
|
||||
println#(k#)
|
||||
|
||||
Reference in New Issue
Block a user