Get rid of static function ConstantExpressionEvaluator.evaluateToConstant

compiler/backend/src/org/jetbrains/kotlin/codegen/MemberCodegen.java

@@ -81,6 +81,7 @@ public abstract class MemberCodegen<T extends JetElement/* TODO: & JetDeclaratio
     private NameGenerator inlineNameGenerator;
 
     private SourceMapper sourceMapper;
+    private final ConstantExpressionEvaluator constantExpressionEvaluator;
 
     public MemberCodegen(
             @NotNull GenerationState state,
@@ -98,6 +99,7 @@ public abstract class MemberCodegen<T extends JetElement/* TODO: & JetDeclaratio
         this.functionCodegen = new FunctionCodegen(context, v, state, this);
         this.propertyCodegen = new PropertyCodegen(context, v, functionCodegen, this);
         this.parentCodegen = parentCodegen;
+        this.constantExpressionEvaluator = new ConstantExpressionEvaluator(state.getModule().getBuiltIns());
     }
 
     protected MemberCodegen(@NotNull MemberCodegen<T> wrapped, T declaration, FieldOwnerContext codegenContext) {
@@ -397,7 +399,7 @@ public abstract class MemberCodegen<T extends JetElement/* TODO: & JetDeclaratio
     ) {
         if (property.isVar() && initializer != null) {
             BindingTrace tempTrace = TemporaryBindingTrace.create(state.getBindingTrace(), "property initializer");
-            return ConstantExpressionEvaluator.evaluateToConstantValue(initializer, tempTrace, propertyDescriptor.getType());
+            return constantExpressionEvaluator.evaluateToConstantValue(initializer, tempTrace, propertyDescriptor.getType());
         }
         return propertyDescriptor.getCompileTimeInitializer();
     }

compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java

@@ -68,6 +68,7 @@ public class DescriptorResolver {
     @NotNull private final DelegatedPropertyResolver delegatedPropertyResolver;
     @NotNull private final StorageManager storageManager;
     @NotNull private final KotlinBuiltIns builtIns;
+    @NotNull private final ConstantExpressionEvaluator constantExpressionEvaluator;
 
     public DescriptorResolver(
             @NotNull AnnotationResolver annotationResolver,
@@ -75,7 +76,8 @@ public class DescriptorResolver {
             @NotNull DelegatedPropertyResolver delegatedPropertyResolver,
             @NotNull ExpressionTypingServices expressionTypingServices,
             @NotNull StorageManager storageManager,
-            @NotNull TypeResolver typeResolver
+            @NotNull TypeResolver typeResolver,
+            @NotNull ConstantExpressionEvaluator constantExpressionEvaluator
     ) {
         this.annotationResolver = annotationResolver;
         this.builtIns = builtIns;
@@ -83,6 +85,7 @@ public class DescriptorResolver {
         this.expressionTypingServices = expressionTypingServices;
         this.storageManager = storageManager;
         this.typeResolver = typeResolver;
+        this.constantExpressionEvaluator = constantExpressionEvaluator;
     }
 
     public List<JetType> resolveSupertypes(
@@ -848,7 +851,7 @@ public class DescriptorResolver {
                 public ConstantValue<?> invoke() {
                     JetExpression initializer = variable.getInitializer();
                     JetType initializerType = expressionTypingServices.safeGetType(scope, initializer, variableType, dataFlowInfo, trace);
-                    return ConstantExpressionEvaluator.evaluateToConstantValue(initializer, trace, initializerType);
+                    return constantExpressionEvaluator.evaluateToConstantValue(initializer, trace, initializerType);
                 }
             }, null)
         );

compiler/frontend/src/org/jetbrains/kotlin/resolve/constants/evaluate/ConstantExpressionEvaluator.kt

@@ -44,9 +44,10 @@ import java.util.HashMap
 import kotlin.platform.platformStatic
 
 public class ConstantExpressionEvaluator(
-        internal val constantValueFactory: ConstantValueFactory,
         internal val builtIns: KotlinBuiltIns
 ) {
+    internal val constantValueFactory = ConstantValueFactory(builtIns)
+
     public fun updateNumberType(
             numberType: JetType,
             expression: JetExpression?,
@@ -201,18 +202,16 @@ public class ConstantExpressionEvaluator(
         return if (!constant.isError) constant else null
     }
 
-    companion object {
+    public fun evaluateToConstantValue(
-        platformStatic public fun evaluateToConstantValue(
+            expression: JetExpression,
-                expression: JetExpression,
+            trace: BindingTrace,
-                trace: BindingTrace,
+            expectedType: JetType
-                expectedType: JetType
+    ): ConstantValue<*>? {
-        ): ConstantValue<*>? {
+        return evaluateExpression(expression, trace, expectedType)?.toConstantValue(expectedType)
-            val builtIns = KotlinBuiltIns.getInstance()
+    }
-            return ConstantExpressionEvaluator(ConstantValueFactory(builtIns), builtIns).
-                    evaluateExpression(expression, trace, expectedType)?.
-                    toConstantValue(expectedType)
-        }
 
+
+    companion object {
         platformStatic public fun getConstant(expression: JetExpression, bindingContext: BindingContext): CompileTimeConstant<*>? {
             val constant = getPossiblyErrorConstant(expression, bindingContext) ?: return null
             return if (!constant.isError) constant else null

compiler/frontend/src/org/jetbrains/kotlin/types/expressions/DataFlowAnalyzer.java

@@ -26,7 +26,6 @@ import org.jetbrains.kotlin.lexer.JetTokens;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.BindingTrace;
-import org.jetbrains.kotlin.resolve.calls.ArgumentTypeResolver;
 import org.jetbrains.kotlin.resolve.calls.checkers.AdditionalTypeChecker;
 import org.jetbrains.kotlin.resolve.calls.context.ResolutionContext;
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo;
@@ -186,7 +185,7 @@ public class DataFlowAnalyzer {
         }
 
         if (expression instanceof JetConstantExpression) {
-            ConstantValue<?> constantValue = ConstantExpressionEvaluator.evaluateToConstantValue(expression, c.trace, c.expectedType);
+            ConstantValue<?> constantValue = constantExpressionEvaluator.evaluateToConstantValue(expression, c.trace, c.expectedType);
             boolean error = new CompileTimeConstantChecker(c.trace, true)
                     .checkConstantExpressionType(constantValue, (JetConstantExpression) expression, c.expectedType);
             if (hasError != null) hasError.set(error);

compiler/tests/org/jetbrains/kotlin/resolve/constants/evaluate/AbstractEvaluateExpressionTest.kt

@@ -66,8 +66,7 @@ public abstract class AbstractEvaluateExpressionTest : AbstractAnnotationDescrip
 
     private fun evaluateInitializer(context: BindingContext, property: VariableDescriptor): CompileTimeConstant<*>? {
         val propertyDeclaration = DescriptorToSourceUtils.descriptorToDeclaration(property) as JetProperty
-        val builtIns = KotlinBuiltIns.getInstance()
+        val compileTimeConstant = ConstantExpressionEvaluator(KotlinBuiltIns.getInstance()).evaluateExpression(
-        val compileTimeConstant = ConstantExpressionEvaluator(ConstantValueFactory(builtIns), builtIns).evaluateExpression(
                 propertyDeclaration.getInitializer()!!,
                 DelegatingBindingTrace(context, "trace for evaluating compile time constant"),
                 property.getType()