Raw FIR: support a bunch of new elements + some fixes

Support: calls, constructor calls, annotation calls, arguments Support: enums, primary constructors, const modifier Support: inner modifier, qualified types Add: some base transformed types Fix: acceptChildren etc. Progress: #KT-24013
2018-03-20 01:14:31 +03:00
parent 2ddf52123a
commit 3e06f426d0
84 changed files with 914 additions and 176 deletions
@@ -0,0 +1,4 @@
+open class A
+
+
+class B : A
@@ -0,0 +1,5 @@
+FILE: F.kt
+    unknown open class A() {
+    }
+    unknown final class B() : A {
+    }
@@ -0,0 +1,9 @@
+abstract class A {
+    abstract class Nested
+}
+
+typealias TA = A
+
+class B : TA() {
+    class NestedInB : Nested()
+}
@@ -0,0 +1,12 @@
+FILE: NestedOfAliasedType.kt
+    unknown abstract class A() {
+        unknown abstract class Nested() {
+        }
+
+    }
+    unknown final typealias TA = A
+    unknown final class B() : TA {
+        unknown final class NestedInB() : Nested {
+        }
+
+    }
@@ -0,0 +1,13 @@
+package p
+
+abstract class My {
+    abstract class NestedOne : My() {
+        abstract class NestedTwo : NestedOne() {
+
+        }
+    }
+}
+
+class Your : My() {
+    class NestedThree : NestedOne()
+}
@@ -0,0 +1,14 @@
+FILE: NestedSuperType.kt
+    unknown abstract class My() {
+        unknown abstract class NestedOne() : My {
+            unknown abstract class NestedTwo() : NestedOne {
+            }
+
+        }
+
+    }
+    unknown final class Your() : My {
+        unknown final class NestedThree() : NestedOne {
+        }
+
+    }
@@ -0,0 +1,11 @@
+package a.b
+
+class C<T, out S> {
+    inner class D<R, in P> {
+
+    }
+}
+
+interface Test {
+    val x: a.b.C<out CharSequence, *>.D<in List<*>, *>
+}
@@ -0,0 +1,11 @@
+FILE: complexTypes.kt
+    <T, out S> unknown final class C() {
+        <R, in P> unknown final class D(inner) {
+        }
+
+    }
+    unknown final interface Test() {
+        unknown final property x(val): a.b.C<out CharSequence, *>.D<in List<*>, *>
+            unknown get(): a.b.C<out CharSequence, *>.D<in List<*>, *>
+
+    }
@@ -0,0 +1,5 @@
+open class Base<T>(val x: T)
+
+class Derived<T : Any>(x: T) : Base<T>(x)
+
+fun <T : Any> create(x: T): Derived<T> = Derived(x)
@@ -0,0 +1,12 @@
+FILE: derivedClass.kt
+    <T> unknown open class Base() {
+        unknown constructor(x: T)
+
+    }
+    <T : Any> unknown final class Derived() : Base<T> {
+        unknown constructor(x: T)STUB
+
+    }
+    <T : Any> unknown final function create(x: T): Derived<T> {
+        STUB
+    }
@@ -0,0 +1,33 @@
+import my.println
+
+enum class Order {
+    FIRST,
+    SECOND,
+    THIRD
+}
+
+enum class Planet(val m: Double, internal val r: Double) {
+    MERCURY(1.0, 2.0) {
+        override fun sayHello() {
+            println("Hello!!!")
+        }
+    },
+    VENERA(3.0, 4.0) {
+        override fun sayHello() {
+            println("Ola!!!")
+        }
+    },
+    EARTH(5.0, 6.0) {
+        override fun sayHello() {
+            println("Privet!!!")
+        }
+    };
+
+    val g: Double = G * m / (r * r)
+
+    abstract fun sayHello()
+
+    companion object {
+        const val G = 6.67e-11
+    }
+}
@@ -0,0 +1,45 @@
+FILE: enums.kt
+    unknown final enum class Order() {
+        unknown final enum entry FIRST() {
+        }
+
+        unknown final enum entry SECOND() {
+        }
+
+        unknown final enum entry THIRD() {
+        }
+
+    }
+    unknown final enum class Planet() {
+        unknown constructor(m: Double, r: Double)
+
+        unknown final enum entry MERCURY() : Planet {
+            unknown final override function sayHello(): <implicit> {
+            }
+
+        }
+
+        unknown final enum entry VENERA() : Planet {
+            unknown final override function sayHello(): <implicit> {
+            }
+
+        }
+
+        unknown final enum entry EARTH() : Planet {
+            unknown final override function sayHello(): <implicit> {
+            }
+
+        }
+
+        unknown final property g(val): Double = STUB
+            unknown get(): Double
+
+        unknown abstract function sayHello(): <implicit>
+
+        unknown final object Companion(companion) {
+            unknown final const property G(val): <implicit> = STUB
+                unknown get(): <implicit>
+
+        }
+
+    }
@@ -0,0 +1,16 @@
+interface Some
+
+object O1 : Some
+
+object O2 : Some
+
+enum class SomeEnum(val x: Some) {
+    FIRST(O1) {
+        override fun check(y: Some): Boolean = true
+    },
+    SECOND(O2)  {
+        override fun check(y: Some): Boolean = y == O2
+    };
+
+    abstract fun check(y: Some): Boolean
+}
@@ -0,0 +1,27 @@
+FILE: enums2.kt
+    unknown final interface Some() {
+    }
+    unknown final object O1() : Some {
+    }
+    unknown final object O2() : Some {
+    }
+    unknown final enum class SomeEnum() {
+        unknown constructor(x: Some)
+
+        unknown final enum entry FIRST() : SomeEnum {
+            unknown final override function check(y: Some): Boolean {
+                STUB
+            }
+
+        }
+
+        unknown final enum entry SECOND() : SomeEnum {
+            unknown final override function check(y: Some): Boolean {
+                STUB
+            }
+
+        }
+
+        unknown abstract function check(y: Some): Boolean
+
+    }
@@ -0,0 +1,8 @@
+fun <T> simpleRun(f: (T) -> Unit): Unit = f()
+
+fun <T, R> List<T>.simpleMap(f: (T) -> R): R {
+
+}
+
+fun <T> simpleWith(t: T, f: T.() -> Unit): Unit = t.f()
+
@@ -0,0 +1,9 @@
+FILE: functionTypes.kt
+    <T> unknown final function simpleRun(f: ( (<no name provided>: T): Unit )): Unit {
+        STUB
+    }
+    <T, R> unknown final function simpleMapList<T>.(f: ( (<no name provided>: T): R )): R {
+    }
+    <T> unknown final function simpleWith(t: T, f: ( T.(): Unit )): Unit {
+        STUB
+    }
@@ -0,0 +1,7 @@
+interface Any
+
+inline fun <reified T : Any> Any.safeAs(): T? = this as? T
+
+abstract class Summator {
+    abstract fun <T> plus(first: T, second: T): T
+}
@@ -0,0 +1,10 @@
+FILE: genericFunctions.kt
+    unknown final interface Any() {
+    }
+    <T : Any> unknown final inline function safeAsAny.(): T? {
+        STUB
+    }
+    unknown abstract class Summator() {
+        <T> unknown abstract function plus(first: T, second: T): T
+
+    }
@@ -0,0 +1,7 @@
+abstract class Base(val s: String)
+
+class Outer {
+    class Derived(s: String) : Base(s)
+
+    object Obj : Base("")
+}
@@ -0,0 +1,15 @@
+FILE: nestedClass.kt
+    unknown abstract class Base() {
+        unknown constructor(s: String)
+
+    }
+    unknown final class Outer() {
+        unknown final class Derived() : Base {
+            unknown constructor(s: String)STUB
+
+        }
+
+        unknown final object Obj() : Base {
+        }
+
+    }
@@ -14,4 +14,6 @@ class SomeClass : SomeInterface {
    override var bar: Boolean
        get() = true
        set(value) {}
+
+    var fau: Double
 }
@@ -1,5 +1,5 @@
 FILE: simpleClass.kt
-    unknown final class SomeInterface() {
+    unknown final interface SomeInterface() {
        unknown final function foo(x: Int, y: String): String

        unknown final property bar(val): Boolean
@@ -20,4 +20,8 @@ FILE: simpleClass.kt
            unknown set(value: Boolean): <implicit> {
            }

+        unknown final property fau(var): Double
+            unknown get(): Double
+            unknown set(value: Double): R/Unit/
+
    }
@@ -0,0 +1,5 @@
+interface B
+
+typealias C = B
+
+class D : C
@@ -0,0 +1,6 @@
+FILE: simpleTypeAlias.kt
+    unknown final interface B() {
+    }
+    unknown final typealias C = B
+    unknown final class D() : C {
+    }
@@ -0,0 +1,7 @@
+open class A
+
+interface B<S, T : A>
+
+typealias C<T> = B<T, A>
+
+class D : C<A>
@@ -0,0 +1,8 @@
+FILE: typeAliasWithGeneric.kt
+    unknown open class A() {
+    }
+    <S, T : A> unknown final interface B() {
+    }
+    unknown final typealias C = B<T, A>
+    unknown final class D() : C<A> {
+    }
@@ -0,0 +1,17 @@
+package test
+
+interface Some
+
+abstract class My<T : Some> {
+    inner class T
+
+    abstract val x: T
+
+    abstract fun foo(arg: T)
+
+    abstract val y: My.T
+
+    abstract val z: test.My.T
+
+    class Some : T()
+}
@@ -0,0 +1,22 @@
+FILE: typeParameterVsNested.kt
+    unknown final interface Some() {
+    }
+    <T : Some> unknown abstract class My() {
+        unknown final class T(inner) {
+        }
+
+        unknown abstract property x(val): T
+            unknown get(): T
+
+        unknown abstract function foo(arg: T): <implicit>
+
+        unknown abstract property y(val): My.T
+            unknown get(): My.T
+
+        unknown abstract property z(val): test.My.T
+            unknown get(): test.My.T
+
+        unknown final class Some() : T {
+        }
+
+    }
@@ -1,5 +1,5 @@
 FILE: typeParameters.kt
-    <out T : Any> unknown final class List() {
+    <out T : Any> unknown final interface List() {
        unknown final operator function get(index: Int): T

        unknown final infix function concat(other: List<T>): List<T>