From fed09f059ba21243df5dd152fafcd8e86a0f4a08 Mon Sep 17 00:00:00 2001
From: Dmitry Petrov <Dmitry.Petrov@jetbrains.com>
Date: Fri, 2 Sep 2016 17:48:37 +0300
Subject: [PATCH] Byte and Short literals.

---
 .../psi2ir/generators/StatementGenerator.kt   | 36 ++++++++++++++-----
 .../kotlin/ir/expressions/IrConst.kt          |  8 +++++
 2 files changed, 35 insertions(+), 9 deletions(-)

diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/StatementGenerator.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/StatementGenerator.kt
index c64b40b1a61..b93c1fac266 100644
--- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/StatementGenerator.kt
+++ b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/StatementGenerator.kt
@@ -193,6 +193,10 @@ class StatementGenerator(
                 IrConstImpl.float(expression.startOffset, expression.endOffset, constantType, constantValue.value)
             is CharValue ->
                 IrConstImpl.char(expression.startOffset, expression.endOffset, constantType, constantValue.value)
+            is ByteValue ->
+                IrConstImpl.byte(expression.startOffset, expression.endOffset, constantType, constantValue.value)
+            is ShortValue ->
+                IrConstImpl.short(expression.startOffset, expression.endOffset, constantType, constantValue.value)
             else ->
                 TODO("handle other literal types: ${constantValue.type}")
         }
@@ -224,23 +228,37 @@ class StatementGenerator(
             entry.expression!!.genExpr()
 
     override fun visitSimpleNameExpression(expression: KtSimpleNameExpression, data: Nothing?): IrExpression {
-        val resolvedCall = getResolvedCall(expression) ?:
-                           return ErrorExpressionGenerator(this).generateErrorExpression(expression)
+        val resolvedCall = getResolvedCall(expression)
 
-        if (resolvedCall is VariableAsFunctionResolvedCall) {
-            val variableCall = pregenerateCall(resolvedCall.variableCall)
-            return CallGenerator(this).generateCall(expression, variableCall, IrOperator.VARIABLE_AS_FUNCTION)
+        if (resolvedCall != null) {
+            if (resolvedCall is VariableAsFunctionResolvedCall) {
+                val variableCall = pregenerateCall(resolvedCall.variableCall)
+                return CallGenerator(this).generateCall(expression, variableCall, IrOperator.VARIABLE_AS_FUNCTION)
+            }
+
+            val descriptor = resolvedCall.resultingDescriptor
+
+            return generateExpressionForReferencedDescriptor(descriptor, expression, resolvedCall)
         }
 
-        val descriptor = resolvedCall.resultingDescriptor
+        val referenceTarget = get(BindingContext.REFERENCE_TARGET, expression)
+        if (referenceTarget != null) {
+            return generateExpressionForReferencedDescriptor(referenceTarget, expression, null)
+        }
 
-        return generateExpressionForReferencedDescriptor(descriptor, expression, resolvedCall)
+        return ErrorExpressionGenerator(this).generateErrorExpression(expression)
     }
 
-    private fun generateExpressionForReferencedDescriptor(descriptor: DeclarationDescriptor, expression: KtExpression, resolvedCall: ResolvedCall<*>): IrExpression =
+    private fun generateExpressionForReferencedDescriptor(
+            descriptor: DeclarationDescriptor,
+            expression: KtExpression,
+            resolvedCall: ResolvedCall<*>?
+    ): IrExpression =
             when (descriptor) {
                 is FakeCallableDescriptorForObject ->
                     generateExpressionForReferencedDescriptor(descriptor.getReferencedDescriptor(), expression, resolvedCall)
+                is TypeAliasDescriptor ->
+                    generateExpressionForReferencedDescriptor(descriptor.classDescriptor!!, expression, null)
                 is ClassDescriptor -> {
                     val classValueType = descriptor.classValueType!!
                     when {
@@ -255,7 +273,7 @@ class StatementGenerator(
                     }
                 }
                 is PropertyDescriptor -> {
-                    CallGenerator(this).generateCall(expression.startOffset, expression.endOffset, pregenerateCall(resolvedCall))
+                    CallGenerator(this).generateCall(expression.startOffset, expression.endOffset, pregenerateCall(resolvedCall!!))
                 }
                 is VariableDescriptor ->
                     CallGenerator(this).generateGetVariable(expression.startOffset, expression.endOffset, descriptor)
diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrConst.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrConst.kt
index 4f87998d69e..2b6c24bba97 100644
--- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrConst.kt
+++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrConst.kt
@@ -34,6 +34,8 @@ sealed class IrConstKind<T>(val asString: kotlin.String)  {
     object Null : IrConstKind<Nothing?>("Null")
     object Boolean : IrConstKind<kotlin.Boolean>("Boolean")
     object Char : IrConstKind<kotlin.Char>("Char")
+    object Byte : IrConstKind<kotlin.Byte>("Byte")
+    object Short : IrConstKind<kotlin.Short>("Short")
     object Int : IrConstKind<kotlin.Int>("Int")
     object Long : IrConstKind<kotlin.Long>("Long")
     object String : IrConstKind<kotlin.String>("String")
@@ -86,6 +88,12 @@ class IrConstImpl<T> (
 
         fun char(startOffset: Int, endOffset: Int, type: KotlinType, value: Char): IrExpression =
                 IrConstImpl(startOffset, endOffset, type, IrConstKind.Char, value)
+
+        fun byte(startOffset: Int, endOffset: Int, type: KotlinType, value: Byte): IrExpression =
+                IrConstImpl(startOffset, endOffset, type, IrConstKind.Byte, value)
+
+        fun short(startOffset: Int, endOffset: Int, type: KotlinType, value: Short): IrExpression =
+                IrConstImpl(startOffset, endOffset, type, IrConstKind.Short, value)
     }
 }