Add basic support for class references

Also use class name for `Any.toString` and `Throwable.toString`.

backend.native/tests/codegen/kclass/kclass0.kt

@@ -0,0 +1,76 @@
+import kotlin.reflect.KClass
+
+fun main(args: Array<String>) {
+    checkClass(Any::class, "kotlin.Any", "Any", Any(), null)
+    checkClass(Int::class, "kotlin.Int", "Int", 42, "17")
+    checkClass(String::class, "kotlin.String", "String", "17", 42)
+    checkClass(RootClass::class, "RootClass", "RootClass", RootClass(), Any())
+    checkClass(RootClass.Nested::class, "RootClass.Nested", "Nested", RootClass.Nested(), Any())
+
+    class Local {
+        val captured = args
+
+        inner class Inner
+    }
+    checkClass(Local::class, null, "Local", Local(), Any())
+    checkClass(Local.Inner::class, null, "Inner", Local().Inner(), Any())
+
+    val obj = object : Any() {
+        val captured = args
+
+        inner class Inner
+        val innerKClass = Inner::class
+    }
+    checkClass(obj::class, null, null, obj, Any())
+    checkClass(obj.innerKClass, null, "Inner", obj.Inner(), Any())
+
+    // Interfaces:
+    checkClass(Comparable::class, "kotlin.Comparable", "Comparable", 42, Any())
+    checkClass(Interface::class, "Interface", "Interface", object : Interface {}, Any())
+
+    checkInstanceClass(Any(), Any::class)
+    checkInstanceClass(42, Int::class)
+    assert(42::class == Int::class)
+
+    checkReifiedClass<Int>(Int::class)
+    checkReifiedClass<Int?>(Int::class)
+    checkReifiedClass2<Int>(Int::class)
+    checkReifiedClass2<Int?>(Int::class)
+    checkReifiedClass<Any>(Any::class)
+    checkReifiedClass2<Any>(Any::class)
+    checkReifiedClass2<Any?>(Any::class)
+    checkReifiedClass<Local>(Local::class)
+    checkReifiedClass2<Local>(Local::class)
+    checkReifiedClass<RootClass>(RootClass::class)
+    checkReifiedClass2<RootClass>(RootClass::class)
+}
+
+class RootClass {
+    class Nested
+}
+interface Interface
+
+fun checkClass(
+        clazz: KClass<*>,
+        expectedQualifiedName: String?, expectedSimpleName: String?,
+        expectedInstance: Any, expectedNotInstance: Any?
+) {
+    assert(clazz.qualifiedName == expectedQualifiedName)
+    assert(clazz.simpleName == expectedSimpleName)
+
+    assert(clazz.isInstance(expectedInstance))
+    if (expectedNotInstance != null) assert(!clazz.isInstance(expectedNotInstance))
+}
+
+fun checkInstanceClass(instance: Any, clazz: KClass<*>) {
+    assert(instance::class == clazz)
+}
+
+inline fun <reified T> checkReifiedClass(expectedClass: KClass<*>) {
+    assert(T::class == expectedClass)
+}
+
+inline fun <reified T> checkReifiedClass2(expectedClass: KClass<*>) {
+    checkReifiedClass<T>(expectedClass)
+    checkReifiedClass<T?>(expectedClass)
+}

backend.native/tests/codegen/kclass/kclass1.kt

@@ -0,0 +1,53 @@
+// FILE: main.kt
+fun main(args: Array<String>) {
+    com.github.salomonbrys.kmffkn.App(testQualified = true)
+}
+
+// FILE: app.kt
+
+// Taken from:
+// https://github.com/SalomonBrys/kmffkn/blob/master/shared/main/kotlin/com/github/salomonbrys/kmffkn/app.kt
+
+package com.github.salomonbrys.kmffkn
+
+@DslMarker
+annotation class MyDsl
+
+@MyDsl
+class DslMain {
+    fun <T: Any> kClass(block: KClassDsl.() -> T): T = KClassDsl().block()
+}
+
+@MyDsl
+class KClassDsl {
+    inline fun <reified T: Any> of() = T::class
+}
+
+fun <T: Any> dsl(block: DslMain.() -> T): T = DslMain().block()
+
+class Test
+
+class App(testQualified: Boolean) {
+
+    @Volatile // This could be noop in Kotlin Native, or the equivalent of volatile in C.
+    var type = dsl {
+        kClass {
+            //kClass {  } // This should error if uncommented because of `@DslMarker`.
+            of<Test>()
+        }
+    }
+
+    init {
+        assert(type.simpleName == "Test")
+        if (testQualified)
+            assert(type.qualifiedName == "com.github.salomonbrys.kmffkn.Test") // This is not really necessary, but always better :).
+
+        assert(String::class == String::class)
+        assert(String::class != Int::class)
+
+        assert(Test()::class == Test()::class)
+        assert(Test()::class == Test::class)
+
+        println("OK :D")
+    }
+}