translator: class fields assignment

translator/src/main/kotlin/org/kotlinnative/translator/ClassCodegen.kt

@@ -19,10 +19,11 @@ class ClassCodegen(val state: TranslationState, val clazz: KtClass, val codeBuil
 
     val annotation: Boolean
     val native: Boolean
-    val fields = ArrayList<LLVMVariable>()
+    val fields = ArrayList<LLVMClassVariable>()
+    val fieldsIndex = HashMap<String, LLVMClassVariable>()
     val name = "%class.${clazz.name}"
     val constructorName = "@${clazz.name}"
-    val type: LLVMType = parseLLVMType(name)
+    val type: LLVMType = LLVMReferenceType(clazz.name.toString(), "class")
     val size: Int
 
     init {
@@ -36,7 +37,10 @@ class ClassCodegen(val state: TranslationState, val clazz: KtClass, val codeBuil
         if (!annotation) {
             for (field in parameterList) {
                 val type = getNativeType(field) ?: parseLLVMType((field.typeReference?.typeElement as KtUserType).referencedName!!)
-                fields.add(LLVMClassVariable(field.name!!, type, offset))
+                val item = LLVMClassVariable(field.name!!, type, offset)
+
+                fields.add(item)
+                fieldsIndex[item.label] = item
 
                 currentSize += type.size
                 offset++
@@ -98,7 +102,7 @@ class ClassCodegen(val state: TranslationState, val clazz: KtClass, val codeBuil
             val argument = codeBuilder.getNewVariable(it.type)
             codeBuilder.loadVariable(argument, LLVMVariable("%${it.label}.addr", it.type, pointer = true))
             val classField = codeBuilder.getNewVariable(it.type, true)
-            codeBuilder.loadClassField(classField, LLVMVariable("%instance.addr", type, pointer = true), (it as LLVMClassVariable).offset)
+            codeBuilder.loadClassField(classField, LLVMVariable("%instance.addr", type, pointer = true), it.offset)
             codeBuilder.storeVariable(classField, argument)
         }
     }

translator/src/main/kotlin/org/kotlinnative/translator/FunctionCodegen.kt

@@ -105,6 +105,7 @@ class FunctionCodegen(val state: TranslationState, val function: KtNamedFunction
             is KtCallExpression -> evaluateCallExpression(expr)
             is KtReferenceExpression -> evaluateReferenceExpression(expr)
             is KtIfExpression -> evaluateIfOperator(expr.firstChild as LeafPsiElement, scopeDepth + 1, true)
+            is KtDotQualifiedExpression -> evaluteDotExpression(expr, scopeDepth)
             is PsiWhiteSpace -> null
             is PsiElement -> evaluatePsiElement(expr, scopeDepth)
             null -> null
@@ -112,6 +113,20 @@ class FunctionCodegen(val state: TranslationState, val function: KtNamedFunction
         }
     }
 
+    private fun evaluteDotExpression(expr: KtDotQualifiedExpression, scopeDepth: Int): LLVMSingleValue? {
+        val receiverName = expr.receiverExpression.text
+        val selectorName = expr.selectorExpression!!.text
+
+        val receiver = variableManager.getLLVMvalue(receiverName)!!
+
+        val clazz = state.classes[(receiver.type as LLVMReferenceType).type]!!
+        val field = clazz.fieldsIndex[selectorName]!!
+
+        val result = codeBuilder.getNewVariable(field.type, pointer = true)
+        codeBuilder.loadClassField(result, receiver, field.offset)
+        return result
+    }
+
     private fun evaluateReferenceExpression(expr: KtReferenceExpression): LLVMSingleValue? {
         val variableName = expr.firstChild.text
         return variableManager.getLLVMvalue(variableName)
@@ -313,10 +328,11 @@ class FunctionCodegen(val state: TranslationState, val function: KtNamedFunction
                 variableManager.addVariable(identifier.text, newVar, scopeDepth)
             }
             is LLVMConstructorCall -> {
-                val result = LLVMVariable("%${identifier!!.text}", assignExpression.type)
+                val result = variableManager.getVariable(identifier!!.text, assignExpression.type, pointer = false)
                 codeBuilder.allocVar(result)
                 result.pointer = true
                 codeBuilder.addLLVMCode(assignExpression.call(result).toString())
+                variableManager.addVariable(identifier.text, result, scopeDepth)
             }
             else -> {
                 codeBuilder.addAssignment(LLVMVariable("%${identifier!!.text}", LLVMIntType(), identifier.text), assignExpression)

translator/src/main/kotlin/org/kotlinnative/translator/llvm/types/LLVMFunctionType.kt

@@ -3,7 +3,6 @@ package org.kotlinnative.translator.llvm.types
 import org.jetbrains.kotlin.types.KotlinType
 import org.kotlinnative.translator.llvm.LLVMMapStandardType
 import org.kotlinnative.translator.llvm.LLVMVariable
-import java.util.*
 
 class LLVMFunctionType(type: KotlinType) : LLVMType() {
     override val align: Int = 4

translator/src/main/kotlin/org/kotlinnative/translator/llvm/types/LLVMReferenceType.kt

@@ -2,11 +2,11 @@ package org.kotlinnative.translator.llvm.types
 
 import java.util.*
 
-class LLVMReferenceType(val type: String) : LLVMType() {
+class LLVMReferenceType(val type: String, val prefix: String = "") : LLVMType() {
 
     override val align = 4
     override val size: Byte = 4
-    override fun toString() = "$type"
+    override fun toString() = "%$prefix.$type"
 
     private val params = ArrayList<String>()