From eadb2d8db548cdeb48fc2b8959012a0b9135ee0a Mon Sep 17 00:00:00 2001 From: Zalim Bashorov Date: Tue, 9 Dec 2014 20:55:36 +0300 Subject: [PATCH] Minor in JS backend: save operation token as member of BinaryOperationTranslator. --- .../operation/AssignmentTranslator.java | 7 ++----- .../operation/BinaryOperationTranslator.java | 21 +++++++++++-------- .../operation/CompareToTranslator.java | 13 +++++------- 3 files changed, 19 insertions(+), 22 deletions(-) diff --git a/js/js.translator/src/org/jetbrains/k2js/translate/operation/AssignmentTranslator.java b/js/js.translator/src/org/jetbrains/k2js/translate/operation/AssignmentTranslator.java index 8335546e0c5..088ef95b296 100644 --- a/js/js.translator/src/org/jetbrains/k2js/translate/operation/AssignmentTranslator.java +++ b/js/js.translator/src/org/jetbrains/k2js/translate/operation/AssignmentTranslator.java @@ -34,7 +34,6 @@ import org.jetbrains.k2js.translate.reference.BackingFieldAccessTranslator; import static org.jetbrains.k2js.translate.utils.BindingUtils.getDescriptorForReferenceExpression; import static org.jetbrains.k2js.translate.utils.BindingUtils.isVariableReassignment; -import static org.jetbrains.k2js.translate.utils.PsiUtils.getOperationToken; import static org.jetbrains.k2js.translate.utils.PsiUtils.getSimpleName; import static org.jetbrains.k2js.translate.utils.PsiUtils.isAssignment; import static org.jetbrains.k2js.translate.utils.TranslationUtils.hasCorrespondingFunctionIntrinsic; @@ -42,10 +41,8 @@ import static org.jetbrains.k2js.translate.utils.TranslationUtils.translateRight public abstract class AssignmentTranslator extends AbstractTranslator { - public static boolean isAssignmentOperator(JetBinaryExpression expression) { - JetToken operationToken = getOperationToken(expression); - return (OperatorConventions.ASSIGNMENT_OPERATIONS.keySet().contains(operationToken) - || isAssignment(operationToken)); + public static boolean isAssignmentOperator(JetToken operationToken) { + return (OperatorConventions.ASSIGNMENT_OPERATIONS.keySet().contains(operationToken) || isAssignment(operationToken)); } @NotNull diff --git a/js/js.translator/src/org/jetbrains/k2js/translate/operation/BinaryOperationTranslator.java b/js/js.translator/src/org/jetbrains/k2js/translate/operation/BinaryOperationTranslator.java index 5f6602b7cba..c64e7ae7c2a 100644 --- a/js/js.translator/src/org/jetbrains/k2js/translate/operation/BinaryOperationTranslator.java +++ b/js/js.translator/src/org/jetbrains/k2js/translate/operation/BinaryOperationTranslator.java @@ -69,6 +69,9 @@ public final class BinaryOperationTranslator extends AbstractTranslator { @NotNull private final JetExpression rightJetExpression; + @NotNull + private final JetToken operationToken; + @Nullable private final CallableDescriptor operationDescriptor; @@ -83,6 +86,7 @@ public final class BinaryOperationTranslator extends AbstractTranslator { assert expression.getRight() != null : "Binary expression should have a right expression: " + expression.getText(); rightJetExpression = expression.getRight(); + this.operationToken = getOperationToken(expression); this.operationDescriptor = getCallableDescriptorForOperationExpression(bindingContext(), expression); } @@ -92,16 +96,16 @@ public final class BinaryOperationTranslator extends AbstractTranslator { if (intrinsic.exists()) { return applyIntrinsic(intrinsic); } - if (getOperationToken(expression).equals(JetTokens.ELVIS)) { + if (operationToken == JetTokens.ELVIS) { return translateElvis(); } - if (isAssignmentOperator(expression)) { + if (isAssignmentOperator(operationToken)) { return AssignmentTranslator.translate(expression, context()); } if (isNotOverloadable()) { return translateAsUnOverloadableBinaryOperation(); } - if (isCompareToCall(expression, context())) { + if (isCompareToCall(operationToken, operationDescriptor)) { return CompareToTranslator.translate(expression, context()); } assert operationDescriptor != null : @@ -187,14 +191,13 @@ public final class BinaryOperationTranslator extends AbstractTranslator { } private boolean isNotOverloadable() { - return operationDescriptor == null; + return OperatorConventions.NOT_OVERLOADABLE.contains(operationToken); } @NotNull private JsExpression translateAsUnOverloadableBinaryOperation() { - JetToken token = getOperationToken(expression); - assert OperatorConventions.NOT_OVERLOADABLE.contains(token); - JsBinaryOperator operator = OperatorTable.getBinaryOperator(token); + assert OperatorConventions.NOT_OVERLOADABLE.contains(operationToken); + JsBinaryOperator operator = OperatorTable.getBinaryOperator(operationToken); JsExpression leftExpression = Translation.translateAsExpression(leftJetExpression, context()); if (JsAstUtils.isEmptyExpression(leftExpression)) { return leftExpression; @@ -207,8 +210,8 @@ public final class BinaryOperationTranslator extends AbstractTranslator { return new JsBinaryOperation(operator, leftExpression, rightExpression); } - assert token.equals(JetTokens.ANDAND) || token.equals(JetTokens.OROR) : "Unsupported binary operation: " + expression.getText(); - boolean isOror = token.equals(JetTokens.OROR); + assert operationToken.equals(JetTokens.ANDAND) || operationToken.equals(JetTokens.OROR) : "Unsupported binary operation: " + expression.getText(); + boolean isOror = operationToken.equals(JetTokens.OROR); JsExpression literalResult = isOror ? JsLiteral.TRUE : JsLiteral.FALSE; leftExpression = isOror ? not(leftExpression) : leftExpression; diff --git a/js/js.translator/src/org/jetbrains/k2js/translate/operation/CompareToTranslator.java b/js/js.translator/src/org/jetbrains/k2js/translate/operation/CompareToTranslator.java index 7f791ad0d58..f92d635f982 100644 --- a/js/js.translator/src/org/jetbrains/k2js/translate/operation/CompareToTranslator.java +++ b/js/js.translator/src/org/jetbrains/k2js/translate/operation/CompareToTranslator.java @@ -20,9 +20,11 @@ import com.google.dart.compiler.backend.js.ast.JsBinaryOperation; import com.google.dart.compiler.backend.js.ast.JsBinaryOperator; import com.google.dart.compiler.backend.js.ast.JsExpression; import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.CallableDescriptor; import org.jetbrains.jet.lang.psi.JetBinaryExpression; import org.jetbrains.jet.lang.types.expressions.OperatorConventions; +import org.jetbrains.jet.lexer.JetToken; import org.jetbrains.k2js.translate.context.TranslationContext; import org.jetbrains.k2js.translate.general.AbstractTranslator; @@ -34,15 +36,10 @@ import static org.jetbrains.k2js.translate.utils.PsiUtils.getOperationToken; public final class CompareToTranslator extends AbstractTranslator { public static boolean isCompareToCall( - @NotNull JetBinaryExpression expression, - @NotNull TranslationContext context + @NotNull JetToken operationToken, + @Nullable CallableDescriptor operationDescriptor ) { - if (!OperatorConventions.COMPARISON_OPERATIONS.contains(getOperationToken(expression))) return false; - - CallableDescriptor operationDescriptor = - getCallableDescriptorForOperationExpression(context.bindingContext(), expression); - - if (operationDescriptor == null) return false; + if (!OperatorConventions.COMPARISON_OPERATIONS.contains(operationToken) || operationDescriptor == null) return false; return isCompareTo(operationDescriptor); }