From 06cb48e300120a916af964deead542061ee43a38 Mon Sep 17 00:00:00 2001
From: Natalia Ukhorskaya <natalia.ukhorskaya@jetbrains.com>
Date: Thu, 14 Nov 2013 14:24:35 +0400
Subject: [PATCH] Add inner visitor for StringEntries

---
 .../evaluate/ConstantExpressionEvaluator.kt   | 74 ++++++++-----------
 .../jet/lang/resolve/AnnotationResolver.java  |  4 +-
 2 files changed, 33 insertions(+), 45 deletions(-)

diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/evaluate/ConstantExpressionEvaluator.kt b/compiler/frontend/src/org/jetbrains/jet/lang/evaluate/ConstantExpressionEvaluator.kt
index 72e6401c783..0af65057b18 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/evaluate/ConstantExpressionEvaluator.kt
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/evaluate/ConstantExpressionEvaluator.kt
@@ -52,21 +52,38 @@ public class ConstantExpressionEvaluator private (val trace: BindingTrace) : Jet
         return null
     }
 
+    private val stringExpressionEvaluator = object : JetVisitor<StringValue, Nothing>() {
+        fun evaluate(entry: JetStringTemplateEntry): StringValue? {
+            return entry.accept(this, null)
+        }
+
+        override fun visitStringTemplateEntryWithExpression(entry: JetStringTemplateEntryWithExpression, data: Nothing?): StringValue? {
+            val expression = entry.getExpression()
+            if (expression == null) return null
+
+            return createStringConstant(this@ConstantExpressionEvaluator.evaluate(expression, KotlinBuiltIns.getInstance().getStringType()))
+        }
+
+        override fun visitLiteralStringTemplateEntry(entry: JetLiteralStringTemplateEntry, data: Nothing?) = StringValue(entry.getText())
+
+        override fun visitEscapeStringTemplateEntry(entry: JetEscapeStringTemplateEntry, data: Nothing?) = StringValue(entry.getUnescapedValue())
+    }
+
     override fun visitConstantExpression(expression: JetConstantExpression, expectedType: JetType?): CompileTimeConstant<*>? {
         return trace.get(BindingContext.COMPILE_TIME_VALUE, expression)
     }
 
     override fun visitParenthesizedExpression(expression: JetParenthesizedExpression, expectedType: JetType?): CompileTimeConstant<*>? {
-        val deparenthesizedExpression = getDeparenthesizedExpression(expression)
-        if (deparenthesizedExpression != null) {
+        val deparenthesizedExpression = JetPsiUtil.deparenthesize(expression)
+        if (deparenthesizedExpression != null && deparenthesizedExpression != expression) {
             return evaluate(deparenthesizedExpression, expectedType)
         }
         return null
     }
 
     override fun visitPrefixExpression(expression: JetPrefixExpression, expectedType: JetType?): CompileTimeConstant<*>? {
-        val deparenthesizedExpression = getDeparenthesizedExpression(expression)
-        return if (deparenthesizedExpression != null) {
+        val deparenthesizedExpression = JetPsiUtil.deparenthesize(expression)
+        return if (deparenthesizedExpression != null && deparenthesizedExpression != expression) {
             evaluate(deparenthesizedExpression, expectedType)
         } else {
             super.visitPrefixExpression(expression, expectedType)
@@ -74,42 +91,22 @@ public class ConstantExpressionEvaluator private (val trace: BindingTrace) : Jet
     }
 
     override fun visitStringTemplateExpression(expression: JetStringTemplateExpression, expectedType: JetType?): CompileTimeConstant<*>? {
-        val stringTemplateEntries = expression.getEntries()
-        if (stringTemplateEntries.size == 1) {
-            return stringTemplateEntries[0].accept(this, null)
-        }
-        else if (stringTemplateEntries.size > 1) {
-            return stringTemplateEntries.fold(StringValue(""): CompileTimeConstant<*>?) {
-                f, s ->
-                if (f != null) {
-                    val second = s.accept(this, null)
-                    if (second == null) {
-                        null
-                    }
-                    else {
-                        createCompileTimeConstant(evaluateBinaryExpression(f, second, Name.identifier("plus")), expectedType)
-                    }
+        return with(StringBuilder()) {
+            var interupted = false
+            for (entry in expression.getEntries()) {
+                val constant = stringExpressionEvaluator.evaluate(entry)
+                if (constant == null) {
+                    interupted = true
+                    break
                 }
                 else {
-                    null
+                    append(constant.getValue())
                 }
             }
+            if (!interupted) createCompileTimeConstant(toString(), expectedType) else null
         }
-        return null
     }
 
-    override fun visitStringTemplateEntryWithExpression(entry: JetStringTemplateEntryWithExpression, expectedType: JetType?): CompileTimeConstant<*>? {
-        val expression = entry.getExpression()
-        if (expression != null) {
-            return createStringConstant(evaluate(expression, expectedType))
-        }
-        return null
-    }
-
-    override fun visitLiteralStringTemplateEntry(entry: JetLiteralStringTemplateEntry, expectedType: JetType?) = StringValue(entry.getText())
-
-    override fun visitEscapeStringTemplateEntry(entry: JetEscapeStringTemplateEntry, expectedType: JetType?) = StringValue(entry.getUnescapedValue())
-
     override fun visitBinaryExpression(expression: JetBinaryExpression, expectedType: JetType?): CompileTimeConstant<*>? {
         val leftExpression = expression.getLeft()
         if (leftExpression == null) {
@@ -298,15 +295,6 @@ public class ConstantExpressionEvaluator private (val trace: BindingTrace) : Jet
     }
 }
 
-private fun getDeparenthesizedExpression(expression: JetExpression): JetExpression? {
-    val deparenthesizedExpr = JetPsiUtil.deparenthesize(expression)
-    if (deparenthesizedExpr == expression) {
-        return null
-    }
-
-    return deparenthesizedExpr
-}
-
 private fun createCompileTimeConstantForEquals(result: Any?, operationToken: IElementType): CompileTimeConstant<*>? {
     if (result is Boolean) {
         return when (operationToken) {
@@ -342,7 +330,7 @@ private fun createCompileTimeConstantForCompareTo(result: Any?, operationToken:
     return null
 }
 
-private fun createStringConstant(value: CompileTimeConstant<*>?): CompileTimeConstant<*>? {
+private fun createStringConstant(value: CompileTimeConstant<*>?): StringValue? {
     return when (value) {
         null -> null
         is StringValue -> value
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnnotationResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnnotationResolver.java
index 98265aac2b4..2ce7e691cd6 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnnotationResolver.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnnotationResolver.java
@@ -24,7 +24,7 @@ import org.jetbrains.jet.lang.descriptors.annotations.Annotated;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptorImpl;
 import org.jetbrains.jet.lang.diagnostics.Errors;
-import org.jetbrains.jet.lang.evaluate.EvaluatePackage;
+import org.jetbrains.jet.lang.evaluate.ConstantExpressionEvaluator;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.calls.CallResolver;
 import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo;
@@ -257,7 +257,7 @@ public class AnnotationResolver {
             @NotNull JetType expectedType,
             @NotNull BindingTrace trace
     ) {
-        return EvaluatePackage.evaluate(expression, trace, expectedType);
+        return ConstantExpressionEvaluator.object$.evaluate(expression, trace, expectedType);
     }
 
     @NotNull