Some tests for inline members.

backend.native/tests/build.gradle

@@ -1739,6 +1739,21 @@ task deserialized_listof0(type: RunKonanTest) {
     source = "serialization/deserialized_listof0.kt"
 }
 
+task deserialized_members(type: LinkKonanTest) {
+    goldValue=
+        "first level\n"+
+        "second level\n"+
+        "third levelxz\n"+
+        "inner first level\n"+
+        "inner second level\n"+
+        "inner third level\n"+
+        "types first level: 13\n"+
+        "types second level cha-cha-cha\n"+
+        "types third level 1\n"
+    lib = "serialization/serialize_members.kt"
+    source = "serialization/deserialize_members.kt"
+}
+
 // Just check that the driver is able to produce runnable binaries.
 task driver0(type: RunDriverKonanTest) {
     goldValue = "Hello, world!\n"

backend.native/tests/serialization/deserialize_members.kt

@@ -0,0 +1,34 @@
+import foo.bar.*
+
+fun main(args: Array<String>) {
+    val c = C()
+    val d = C.D()
+    val e = C.D.E()
+    c.foo()
+    d.foo()
+    e.foo()
+
+    val c2 = C2()
+    val d2 = C2().D2()
+    val e2 = C2().D2().E2()
+    c2.foo()
+    d2.foo()
+    e2.foo()
+
+    val c3 = C3<Int>()
+    val d3 = C3.D3<String>()
+    val e3 = C3.D3.E3<Float>()
+    c3.foo(13)
+    d3.foo("cha-cha-cha")
+    e3.foo(1.0f)
+    
+    // This part doesn't work with file local inline functions.
+    // So disabled for now.
+    // val c4 = C4<Int>()
+    // val d4 = C4<String>().D4<Int>()
+    // val e4 = C4<Int>().D4<String>().E4<Int>()
+    // c4.foo(13)
+    // d4.foo("cawabunga", 17)
+    // e4.foo(19, "raqa-taqa", 23)
+
+}

backend.native/tests/serialization/serialize_members.kt

@@ -0,0 +1,80 @@
+package foo.bar
+
+class R<T> {
+    inline fun bar(t: T) {
+        println("just a single class: $t")
+    }
+}
+
+class C {
+    inline fun foo() {
+        println("first level")
+    }
+
+    class D {
+        inline fun foo() {
+            println("second level")
+        }
+
+        class E {
+            inline fun foo() {
+                println("third levelxz")
+            }
+        }
+    }
+}
+
+class C2 {
+    inline fun foo() {
+        println("inner first level")
+    }
+
+    inner class D2 {
+        inline fun foo() {
+            println("inner second level")
+        }
+
+        inner class E2 {
+            inline fun foo() {
+                println("inner third level")
+            }
+        }
+    }
+}
+
+class C3<X> {
+    inline fun foo(x: X) {
+        println("types first level: $x")
+    }
+
+    class D3<X> {
+        inline fun foo(x: X) {
+            println("types second level $x")
+        }
+
+        class E3<X> {
+            inline fun foo(x: X) {
+                println("types third level $x")
+            }
+        }
+    }
+}
+
+class C4<X> {
+    inline fun foo(x: X) {
+        println("inner types first level: $x")
+    }
+
+    inner class D4<Y> {
+        inline fun foo(x: X, y: Y) {
+            println("inner types second level $x, $y")
+        }
+
+        inner class E4<Z> {
+            inline fun foo(x: X, y: Y, z: Z) {
+                println("inner types third level $x, $y, $z")
+            }
+        }
+    }
+}
+