From 9fcad45edbb5ba562f85604fe1924b8caf51c28e Mon Sep 17 00:00:00 2001 From: Alexey Andreev Date: Mon, 23 May 2016 14:00:47 +0300 Subject: [PATCH] JS: refactor generation of temporary variables --- .../js/translate/callTranslator/CallInfo.kt | 9 +-- .../translate/context/TemporaryVariable.java | 10 +-- .../translate/context/TranslationContext.java | 7 +++ .../js/translate/expression/LoopTranslator.kt | 62 +++++++------------ .../translate/expression/WhenTranslator.java | 8 +-- .../operation/BinaryOperationTranslator.java | 14 +---- .../reference/AccessTranslationUtils.java | 9 +-- .../reference/CallArgumentTranslator.kt | 5 +- .../QualifiedExpressionTranslator.java | 7 +-- 9 files changed, 45 insertions(+), 86 deletions(-) diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/callTranslator/CallInfo.kt b/js/js.translator/src/org/jetbrains/kotlin/js/translate/callTranslator/CallInfo.kt index 048dae5a379..bafe3190573 100644 --- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/callTranslator/CallInfo.kt +++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/callTranslator/CallInfo.kt @@ -25,8 +25,6 @@ import org.jetbrains.kotlin.descriptors.FunctionDescriptor import org.jetbrains.kotlin.diagnostics.DiagnosticUtils import org.jetbrains.kotlin.js.translate.context.TranslationContext import org.jetbrains.kotlin.js.translate.reference.CallArgumentTranslator -import org.jetbrains.kotlin.js.translate.utils.JsAstUtils -import org.jetbrains.kotlin.js.translate.utils.JsAstUtils.asSyntheticStatement import org.jetbrains.kotlin.js.translate.utils.JsDescriptorUtils.getReceiverParameterForReceiver import org.jetbrains.kotlin.js.translate.utils.TranslationUtils import org.jetbrains.kotlin.resolve.calls.callUtil.isSafeCall @@ -78,17 +76,14 @@ fun TranslationContext.getCallInfo(resolvedCall: ResolvedCall if(!tmpExprVar) break; } else tmpSecondRun=true; } while(true) - val secondRun = context.declareTemporary(JsLiteral.FALSE) - context.addStatementToCurrentBlock(JsAstUtils.asSyntheticStatement(secondRun.assignmentExpression())) + val secondRun = context.defineTemporary(JsLiteral.FALSE) conditionBlock.statements.add(breakIfConditionIsFalseStatement) - val ifStatement = JsIf(secondRun.reference(), conditionBlock, assignment(secondRun.reference(), JsLiteral.TRUE).makeStmt()) + val ifStatement = JsIf(secondRun, conditionBlock, assignment(secondRun, JsLiteral.TRUE).makeStmt()) bodyBlock.statements.add(0, ifStatement) } else { @@ -146,22 +143,19 @@ fun translateForExpression(expression: KtForExpression, context: TranslationCont val rightExpression = TranslationUtils.translateRightExpression(context, loopRange, endBlock) val rangeStart = if (TranslationUtils.isCacheNeeded(leftExpression)) { - val startVar = context.declareTemporary(leftExpression) - context.addStatementToCurrentBlock(asSyntheticStatement(startVar.assignmentExpression())) - startVar.reference() + context.defineTemporary(leftExpression) } else { leftExpression } context.addStatementsToCurrentBlockFrom(startBlock) context.addStatementsToCurrentBlockFrom(endBlock) - val rangeEnd = context.declareTemporary(rightExpression) + val rangeEnd = context.defineTemporary(rightExpression) val body = translateBody(null) - val conditionExpression = lessThanEq(parameterName.makeRef(), rangeEnd.reference()) + val conditionExpression = lessThanEq(parameterName.makeRef(), rangeEnd) val incrementExpression = JsPostfixOperation(JsUnaryOperator.INC, parameterName.makeRef()) - context.addStatementToCurrentBlock(asSyntheticStatement(rangeEnd.assignmentExpression())) return if (parameterIsTemporary) { JsFor(assignment(parameterName.makeRef(), rangeStart), conditionExpression, incrementExpression, body) } @@ -171,46 +165,40 @@ fun translateForExpression(expression: KtForExpression, context: TranslationCont } fun translateForOverRange(): JsStatement { - val rangeExpression = context.declareTemporary(Translation.translateAsExpression(loopRange, context)) + val rangeExpression = context.defineTemporary(Translation.translateAsExpression(loopRange, context)) - fun getProperty(funName: String): JsExpression = JsNameRef(funName, rangeExpression.reference()) + fun getProperty(funName: String): JsExpression = JsNameRef(funName, rangeExpression) - val start = context.declareTemporary(getProperty("first")) - val end = context.declareTemporary(getProperty("last")) - val increment = context.declareTemporary(getProperty("step")) + val start = context.defineTemporary(getProperty("first")) + val end = context.defineTemporary(getProperty("last")) + val increment = context.defineTemporary(getProperty("step")) val body = translateBody(null) - val conditionExpression = lessThanEq(parameterName.makeRef(), end.reference()) - val incrementExpression = addAssign(parameterName.makeRef(), increment.reference()) + val conditionExpression = lessThanEq(parameterName.makeRef(), end) + val incrementExpression = addAssign(parameterName.makeRef(), increment) - context.addStatementToCurrentBlock(asSyntheticStatement(rangeExpression.assignmentExpression())) - context.addStatementToCurrentBlock(asSyntheticStatement(start.assignmentExpression())) - context.addStatementToCurrentBlock(asSyntheticStatement(end.assignmentExpression())) - context.addStatementToCurrentBlock(asSyntheticStatement(increment.assignmentExpression())) return if (parameterIsTemporary) { - JsFor(assignment(parameterName.makeRef(), start.reference()), conditionExpression, incrementExpression, body) + JsFor(assignment(parameterName.makeRef(), start), conditionExpression, incrementExpression, body) } else { - JsFor(newVar(parameterName, start.reference()), conditionExpression, incrementExpression, body) + JsFor(newVar(parameterName, start), conditionExpression, incrementExpression, body) } } fun translateForOverArray(): JsStatement { - val rangeExpression = context.declareTemporary(Translation.translateAsExpression(loopRange, context)) - val length = CompositeFIF.LENGTH_PROPERTY_INTRINSIC.apply(rangeExpression.reference(), listOf(), context) - val end = context.declareTemporary(length) + val rangeExpression = context.defineTemporary(Translation.translateAsExpression(loopRange, context)) + val length = CompositeFIF.LENGTH_PROPERTY_INTRINSIC.apply(rangeExpression, listOf(), context) + val end = context.defineTemporary(length) val index = context.declareTemporary(context.program().getNumberLiteral(0)) - val arrayAccess = JsArrayAccess(rangeExpression.reference(), index.reference()) + val arrayAccess = JsArrayAccess(rangeExpression, index.reference()) val body = translateBody(arrayAccess) - val initExpression = assignment(index.name().makeRef(), context.program().getNumberLiteral(0)) - val conditionExpression = inequality(index.reference(), end.reference()) + val initExpression = assignment(index.reference(), context.program().getNumberLiteral(0)) + val conditionExpression = inequality(index.reference(), end) val incrementExpression = JsPrefixOperation(JsUnaryOperator.INC, index.reference()) - context.addStatementToCurrentBlock(asSyntheticStatement(rangeExpression.assignmentExpression())) - context.addStatementToCurrentBlock(asSyntheticStatement(end.assignmentExpression())) return JsFor(initExpression, conditionExpression, incrementExpression, body) } @@ -225,18 +213,14 @@ fun translateForExpression(expression: KtForExpression, context: TranslationCont return translateMethodInvocation(range, resolvedCall) } - val iteratorVar: TemporaryVariable = context.declareTemporary(iteratorMethodInvocation()) - - fun nextMethodInvocation(): JsExpression = - translateMethodInvocation(iteratorVar.reference(), getNextFunction(context.bindingContext(), loopRange)) + val iteratorVar = context.defineTemporary(iteratorMethodInvocation()) fun hasNextMethodInvocation(): JsExpression { val resolvedCall = getHasNextCallable(context.bindingContext(), loopRange) - return translateMethodInvocation(iteratorVar.reference(), resolvedCall) + return translateMethodInvocation(iteratorVar, resolvedCall) } - context.addStatementToCurrentBlock(iteratorVar.assignmentExpression().makeStmt()) - val nextInvoke = nextMethodInvocation() + val nextInvoke = translateMethodInvocation(iteratorVar, getNextFunction(context.bindingContext(), loopRange)) val body = translateBody(nextInvoke) return JsWhile(hasNextMethodInvocation(), body ?: nextInvoke.makeStmt()) } diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/WhenTranslator.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/WhenTranslator.java index 37a18e5e631..5b32edf2f0a 100644 --- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/WhenTranslator.java +++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/WhenTranslator.java @@ -19,7 +19,6 @@ package org.jetbrains.kotlin.js.translate.expression; import com.google.dart.compiler.backend.js.ast.*; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.kotlin.js.translate.context.TemporaryVariable; import org.jetbrains.kotlin.js.translate.context.TranslationContext; import org.jetbrains.kotlin.js.translate.general.AbstractTranslator; import org.jetbrains.kotlin.js.translate.general.Translation; @@ -34,7 +33,6 @@ import org.jetbrains.kotlin.types.KotlinType; import java.util.HashMap; import java.util.Map; -import static org.jetbrains.kotlin.js.translate.utils.JsAstUtils.asSyntheticStatement; import static org.jetbrains.kotlin.js.translate.utils.JsAstUtils.negated; public final class WhenTranslator extends AbstractTranslator { @@ -56,11 +54,7 @@ public final class WhenTranslator extends AbstractTranslator { KtExpression subject = expression.getSubjectExpression(); if (subject != null) { - JsExpression subjectExpression = Translation.translateAsExpression(subject, context); - TemporaryVariable subjectVar = context.declareTemporary(null); - context.addStatementToCurrentBlock(asSyntheticStatement(JsAstUtils.assignment(subjectVar.reference(), subjectExpression))); - subjectExpression = subjectVar.reference(); - expressionToMatch = subjectExpression; + expressionToMatch = context.defineTemporary(Translation.translateAsExpression(subject, context)); } else { expressionToMatch = null; diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/operation/BinaryOperationTranslator.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/operation/BinaryOperationTranslator.java index 26ab360a58e..60d1984d4df 100644 --- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/operation/BinaryOperationTranslator.java +++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/operation/BinaryOperationTranslator.java @@ -22,7 +22,6 @@ import org.jetbrains.annotations.Nullable; import org.jetbrains.kotlin.descriptors.CallableDescriptor; import org.jetbrains.kotlin.descriptors.FunctionDescriptor; import org.jetbrains.kotlin.js.translate.callTranslator.CallTranslator; -import org.jetbrains.kotlin.js.translate.context.TemporaryVariable; import org.jetbrains.kotlin.js.translate.context.TranslationContext; import org.jetbrains.kotlin.js.translate.general.AbstractTranslator; import org.jetbrains.kotlin.js.translate.general.Translation; @@ -46,7 +45,6 @@ import java.util.Collections; import static org.jetbrains.kotlin.js.translate.operation.AssignmentTranslator.isAssignmentOperator; import static org.jetbrains.kotlin.js.translate.operation.CompareToTranslator.isCompareToCall; import static org.jetbrains.kotlin.js.translate.utils.BindingUtils.getCallableDescriptorForOperationExpression; -import static org.jetbrains.kotlin.js.translate.utils.JsAstUtils.asSyntheticStatement; import static org.jetbrains.kotlin.js.translate.utils.JsAstUtils.not; import static org.jetbrains.kotlin.js.translate.utils.PsiUtils.*; @@ -137,9 +135,7 @@ public final class BinaryOperationTranslator extends AbstractTranslator { JsIf ifStatement; if (BindingContextUtilsKt.isUsedAsExpression(expression, context().bindingContext())) { if (TranslationUtils.isCacheNeeded(leftExpression)) { - TemporaryVariable resultVar = context().declareTemporary(leftExpression); - result = resultVar.reference(); - context().addStatementToCurrentBlock(asSyntheticStatement(resultVar.assignmentExpression())); + result = context().defineTemporary(leftExpression); } else { result = leftExpression; @@ -174,9 +170,7 @@ public final class BinaryOperationTranslator extends AbstractTranslator { } if (TranslationUtils.isCacheNeeded(leftExpression)) { - TemporaryVariable temporaryVariable = context().declareTemporary(null); - context().addStatementToCurrentBlock(asSyntheticStatement(JsAstUtils.assignment(temporaryVariable.reference(), leftExpression))); - leftExpression = temporaryVariable.reference(); + leftExpression = context().defineTemporary(leftExpression); } context().addStatementsToCurrentBlockFrom(rightBlock); @@ -215,9 +209,7 @@ public final class BinaryOperationTranslator extends AbstractTranslator { if (rightExpression instanceof JsNameRef) { result = rightExpression; // Reuse tmp variable } else { - TemporaryVariable resultVar = context().declareTemporary(rightExpression); - result = resultVar.reference(); - rightBlock.getStatements().add(resultVar.assignmentExpression().makeStmt()); + result = context().defineTemporary(rightExpression); } JsStatement assignmentStatement = JsAstUtils.assignment(result, literalResult).makeStmt(); ifStatement = JsAstUtils.newJsIf(leftExpression, rightBlock, assignmentStatement); diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/AccessTranslationUtils.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/AccessTranslationUtils.java index 34d1fae3577..5e8d50e7a35 100644 --- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/AccessTranslationUtils.java +++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/AccessTranslationUtils.java @@ -19,17 +19,13 @@ package org.jetbrains.kotlin.js.translate.reference; import com.google.dart.compiler.backend.js.ast.JsExpression; import org.jetbrains.annotations.NotNull; import org.jetbrains.kotlin.psi.*; -import org.jetbrains.kotlin.js.translate.context.TemporaryVariable; import org.jetbrains.kotlin.js.translate.context.TranslationContext; import org.jetbrains.kotlin.js.translate.general.Translation; -import org.jetbrains.kotlin.js.translate.utils.JsAstUtils; import org.jetbrains.kotlin.js.translate.utils.TranslationUtils; import java.util.LinkedHashMap; import java.util.Map; -import static org.jetbrains.kotlin.js.translate.utils.JsAstUtils.asSyntheticStatement; - public final class AccessTranslationUtils { private AccessTranslationUtils() { } @@ -67,10 +63,7 @@ public final class AccessTranslationUtils { for(KtExpression indexExpression : expression.getIndexExpressions()) { JsExpression jsIndexExpression = Translation.translateAsExpression(indexExpression, context); if (TranslationUtils.isCacheNeeded(jsIndexExpression)) { - TemporaryVariable temporaryVariable = context.declareTemporary(null); - context.addStatementToCurrentBlock( - asSyntheticStatement(JsAstUtils.assignment(temporaryVariable.reference(), jsIndexExpression))); - jsIndexExpression = temporaryVariable.reference(); + jsIndexExpression = context.defineTemporary(jsIndexExpression); } indexesMap.put(indexExpression, jsIndexExpression); } diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/CallArgumentTranslator.kt b/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/CallArgumentTranslator.kt index f34a0833c1b..b3e6897513a 100644 --- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/CallArgumentTranslator.kt +++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/CallArgumentTranslator.kt @@ -29,7 +29,6 @@ import org.jetbrains.kotlin.js.translate.general.AbstractTranslator import org.jetbrains.kotlin.js.translate.general.Translation import org.jetbrains.kotlin.js.translate.utils.AnnotationsUtils import org.jetbrains.kotlin.js.translate.utils.JsAstUtils -import org.jetbrains.kotlin.js.translate.utils.JsAstUtils.asSyntheticStatement import org.jetbrains.kotlin.js.translate.utils.TranslationUtils import org.jetbrains.kotlin.psi.ValueArgument import org.jetbrains.kotlin.resolve.calls.model.* @@ -296,9 +295,7 @@ class CallArgumentTranslator private constructor( val argContext = argContexts[i] val jsArgExpression = argExpressions[i] if (argContext.currentBlockIsEmpty() && TranslationUtils.isCacheNeeded(jsArgExpression)) { - val temporaryVariable = context.declareTemporary(jsArgExpression) - context.addStatementToCurrentBlock(asSyntheticStatement(temporaryVariable.assignmentExpression())) - argExpressions[i] = temporaryVariable.reference() + argExpressions[i] = context.defineTemporary(jsArgExpression) } else { context.addStatementsToCurrentBlockFrom(argContext) diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/QualifiedExpressionTranslator.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/QualifiedExpressionTranslator.java index 6dceb53bc55..ef34eb42312 100644 --- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/QualifiedExpressionTranslator.java +++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/QualifiedExpressionTranslator.java @@ -22,17 +22,14 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.kotlin.descriptors.DeclarationDescriptor; import org.jetbrains.kotlin.descriptors.PackageViewDescriptor; -import org.jetbrains.kotlin.js.translate.context.TemporaryVariable; import org.jetbrains.kotlin.js.translate.context.TranslationContext; import org.jetbrains.kotlin.js.translate.utils.ErrorReportingUtils; -import org.jetbrains.kotlin.js.translate.utils.JsAstUtils; import org.jetbrains.kotlin.psi.*; import org.jetbrains.kotlin.resolve.calls.callUtil.CallUtilKt; import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall; import static org.jetbrains.kotlin.js.translate.general.Translation.translateAsExpression; import static org.jetbrains.kotlin.js.translate.utils.BindingUtils.getDescriptorForReferenceExpression; -import static org.jetbrains.kotlin.js.translate.utils.JsAstUtils.asSyntheticStatement; import static org.jetbrains.kotlin.js.translate.utils.PsiUtils.getNotNullSimpleNameSelector; import static org.jetbrains.kotlin.js.translate.utils.PsiUtils.getSelector; @@ -46,9 +43,7 @@ public final class QualifiedExpressionTranslator { @NotNull TranslationContext context, boolean forceOrderOfEvaluation) { JsExpression receiver = translateReceiver(expression, context); if (forceOrderOfEvaluation && receiver != null) { - TemporaryVariable temporaryVariable = context.declareTemporary(null); - context.addStatementToCurrentBlock(asSyntheticStatement(JsAstUtils.assignment(temporaryVariable.reference(), receiver))); - receiver = temporaryVariable.reference(); + receiver = context.defineTemporary(receiver); } return VariableAccessTranslator.newInstance(context, getNotNullSimpleNameSelector(expression), receiver); }