001 /*
002 * Copyright 2010-2015 JetBrains s.r.o.
003 *
004 * Licensed under the Apache License, Version 2.0 (the "License");
005 * you may not use this file except in compliance with the License.
006 * You may obtain a copy of the License at
007 *
008 * http://www.apache.org/licenses/LICENSE-2.0
009 *
010 * Unless required by applicable law or agreed to in writing, software
011 * distributed under the License is distributed on an "AS IS" BASIS,
012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013 * See the License for the specific language governing permissions and
014 * limitations under the License.
015 */
016
017 package org.jetbrains.kotlin.js.translate.operation;
018
019 import com.google.dart.compiler.backend.js.ast.JsBinaryOperation;
020 import com.google.dart.compiler.backend.js.ast.JsBinaryOperator;
021 import com.google.dart.compiler.backend.js.ast.JsExpression;
022 import com.google.dart.compiler.util.AstUtil;
023 import com.intellij.psi.tree.IElementType;
024 import org.jetbrains.annotations.NotNull;
025 import org.jetbrains.kotlin.descriptors.CallableDescriptor;
026 import org.jetbrains.kotlin.js.translate.context.TemporaryVariable;
027 import org.jetbrains.kotlin.js.translate.context.TranslationContext;
028 import org.jetbrains.kotlin.js.translate.general.AbstractTranslator;
029 import org.jetbrains.kotlin.js.translate.reference.AccessTranslator;
030 import org.jetbrains.kotlin.psi.KtExpression;
031 import org.jetbrains.kotlin.psi.KtUnaryExpression;
032 import org.jetbrains.kotlin.resolve.calls.tasks.DynamicCallsKt;
033 import org.jetbrains.kotlin.types.expressions.OperatorConventions;
034
035 import static org.jetbrains.kotlin.js.translate.reference.AccessTranslationUtils.getAccessTranslator;
036 import static org.jetbrains.kotlin.js.translate.utils.BindingUtils.getCallableDescriptorForOperationExpression;
037 import static org.jetbrains.kotlin.js.translate.utils.PsiUtils.getBaseExpression;
038 import static org.jetbrains.kotlin.js.translate.utils.PsiUtils.isPrefix;
039 import static org.jetbrains.kotlin.js.translate.utils.TranslationUtils.hasCorrespondingFunctionIntrinsic;
040
041 // TODO: provide better increment translator logic
042 public abstract class IncrementTranslator extends AbstractTranslator {
043
044 public static boolean isIncrement(IElementType operationToken) {
045 //noinspection SuspiciousMethodCalls
046 return OperatorConventions.INCREMENT_OPERATIONS.contains(operationToken);
047 }
048
049 @NotNull
050 public static JsExpression translate(@NotNull KtUnaryExpression expression,
051 @NotNull TranslationContext context) {
052 if (hasCorrespondingFunctionIntrinsic(context, expression) || isDynamic(context, expression)) {
053 return IntrinsicIncrementTranslator.doTranslate(expression, context);
054 }
055 return (new OverloadedIncrementTranslator(expression, context)).translateIncrementExpression();
056 }
057
058 @NotNull
059 protected final KtUnaryExpression expression;
060 @NotNull
061 protected final AccessTranslator accessTranslator;
062
063 protected IncrementTranslator(@NotNull KtUnaryExpression expression,
064 @NotNull TranslationContext context) {
065 super(context);
066 this.expression = expression;
067 KtExpression baseExpression = getBaseExpression(expression);
068 this.accessTranslator = getAccessTranslator(baseExpression, context()).getCached();
069 }
070
071 @NotNull
072 protected JsExpression translateIncrementExpression() {
073 if (isPrefix(expression)) {
074 return asPrefix();
075 }
076 return asPostfix();
077 }
078
079 //TODO: decide if this expression can be optimised in case of direct access (not property)
080 @NotNull
081 private JsExpression asPrefix() {
082 // code fragment: expr(a++)
083 // generate: expr(a = a.inc(), a)
084 JsExpression getExpression = accessTranslator.translateAsGet();
085 JsExpression reassignment = variableReassignment(getExpression);
086 JsExpression getNewValue = accessTranslator.translateAsGet();
087 return new JsBinaryOperation(JsBinaryOperator.COMMA, reassignment, getNewValue);
088 }
089
090 //TODO: decide if this expression can be optimised in case of direct access (not property)
091 @NotNull
092 private JsExpression asPostfix() {
093 // code fragment: expr(a++)
094 // generate: expr( (t1 = a, t2 = t1, a = t1.inc(), t2) )
095 TemporaryVariable t1 = context().declareTemporary(accessTranslator.translateAsGet());
096 TemporaryVariable t2 = context().declareTemporary(t1.reference());
097 JsExpression variableReassignment = variableReassignment(t1.reference());
098 return AstUtil.newSequence(t1.assignmentExpression(), t2.assignmentExpression(),
099 variableReassignment, t2.reference());
100 }
101
102 @NotNull
103 private JsExpression variableReassignment(@NotNull JsExpression toCallMethodUpon) {
104 JsExpression overloadedMethodCallOnPropertyGetter = operationExpression(toCallMethodUpon);
105 return accessTranslator.translateAsSet(overloadedMethodCallOnPropertyGetter);
106 }
107
108 @NotNull
109 abstract JsExpression operationExpression(@NotNull JsExpression receiver);
110
111 private static boolean isDynamic(TranslationContext context, KtUnaryExpression expression) {
112 CallableDescriptor operationDescriptor = getCallableDescriptorForOperationExpression(context.bindingContext(), expression);
113 return DynamicCallsKt.isDynamic(operationDescriptor);
114 }
115 }