context().bindingContext() -> bindingContext() (same for program() and aliaser())

refactored CallExpressionTranslator, also worked on vararg problem

translator/src/org/jetbrains/k2js/translate/declaration/ClassDeclarationTranslator.java

@@ -117,8 +117,8 @@ public final class ClassDeclarationTranslator extends AbstractTranslator {
 
     private void removeAliases() {
         for (JetClass jetClass : getClassDeclarations()) {
-            ClassDescriptor descriptor = BindingUtils.getClassDescriptor(context().bindingContext(), jetClass);
+            ClassDescriptor descriptor = BindingUtils.getClassDescriptor(bindingContext(), jetClass);
-            context().aliaser().removeAliasForDescriptor(descriptor);
+            aliaser().removeAliasForDescriptor(descriptor);
         }
     }
 
@@ -126,9 +126,9 @@ public final class ClassDeclarationTranslator extends AbstractTranslator {
     private List<JetClass> getClassDeclarations() {
         List<JetClass> classes = new ArrayList<JetClass>();
         for (ClassDescriptor classDescriptor : descriptors) {
-            classes.add(BindingUtils.getClassForDescriptor(context().bindingContext(), classDescriptor));
+            classes.add(BindingUtils.getClassForDescriptor(bindingContext(), classDescriptor));
         }
-        return ClassSorter.sortUsingInheritanceOrder(classes, context().bindingContext());
+        return ClassSorter.sortUsingInheritanceOrder(classes, bindingContext());
     }
 
     @NotNull
@@ -144,8 +144,8 @@ public final class ClassDeclarationTranslator extends AbstractTranslator {
         JsName globalClassName = context().getNameForElement(declaration);
         JsName localAlias = dummyFunctionScope.declareTemporary();
         localToGlobalClassName.put(localAlias, globalClassName);
-        ClassDescriptor descriptor = BindingUtils.getClassDescriptor(context().bindingContext(), declaration);
+        ClassDescriptor descriptor = BindingUtils.getClassDescriptor(bindingContext(), declaration);
-        context().aliaser().setAliasForDescriptor(descriptor, localAlias);
+        aliaser().setAliasForDescriptor(descriptor, localAlias);
         return localAlias;
     }
 

translator/src/org/jetbrains/k2js/translate/declaration/ClassTranslator.java

@@ -142,8 +142,8 @@ public final class ClassTranslator extends AbstractTranslator {
     @NotNull
     private JsExpression getClassReference(@NotNull ClassDescriptor superClassDescriptor) {
         //NOTE: aliasing here is needed for the declaration generation step
-        if (context().aliaser().hasAliasForDeclaration(superClassDescriptor)) {
+        if (aliaser().hasAliasForDeclaration(superClassDescriptor)) {
-            return context().aliaser().getAliasForDeclaration(superClassDescriptor).makeRef();
+            return aliaser().getAliasForDeclaration(superClassDescriptor).makeRef();
         }
         return context().getNameForDescriptor(superClassDescriptor).makeRef();
     }
@@ -171,7 +171,7 @@ public final class ClassTranslator extends AbstractTranslator {
         List<JsPropertyInitializer> result = new ArrayList<JsPropertyInitializer>();
         for (JetParameter parameter : getPrimaryConstructorParameters(classDeclaration)) {
             PropertyDescriptor descriptor =
-                    getPropertyDescriptorForConstructorParameter(context().bindingContext(), parameter);
+                    getPropertyDescriptorForConstructorParameter(bindingContext(), parameter);
             if (descriptor != null) {
                 result.addAll(PropertyTranslator.translateAccessors(descriptor, context()));
             }

translator/src/org/jetbrains/k2js/translate/declaration/NamespaceTranslator.java

@@ -55,7 +55,7 @@ public final class NamespaceTranslator extends AbstractTranslator {
     //TODO: at the moment this check is very ineffective, possible solution is to cash the result of getDFN
     // other solution is to determine it's not affecting performance :D
     public boolean isNamespaceEmpty() {
-        return BindingUtils.getDeclarationsForNamespace(context().bindingContext(), descriptor).isEmpty();
+        return BindingUtils.getDeclarationsForNamespace(bindingContext(), descriptor).isEmpty();
     }
 
 

translator/src/org/jetbrains/k2js/translate/declaration/PropertyTranslator.java

@@ -59,7 +59,7 @@ public final class PropertyTranslator extends AbstractTranslator {
     private PropertyTranslator(@NotNull PropertyDescriptor property, @NotNull TranslationContext context) {
         super(context);
         this.property = property;
-        this.declaration = BindingUtils.getPropertyForDescriptor(context().bindingContext(), property);
+        this.declaration = BindingUtils.getPropertyForDescriptor(bindingContext(), property);
     }
 
     @NotNull

translator/src/org/jetbrains/k2js/translate/expression/FunctionTranslator.java

@@ -203,7 +203,7 @@ public final class FunctionTranslator extends AbstractTranslator {
             JsName receiver = functionBodyContext.jsScope().declareName(Namer.getReceiverParameterName());
             DeclarationDescriptor expectedReceiverDescriptor = getExpectedReceiverDescriptor(descriptor);
             assert expectedReceiverDescriptor != null;
-            context().aliaser().setAliasForThis(expectedReceiverDescriptor, receiver);
+            aliaser().setAliasForThis(expectedReceiverDescriptor, receiver);
             jsParameters.add(new JsParameter(receiver));
         }
     }

translator/src/org/jetbrains/k2js/translate/expression/PatternTranslator.java

@@ -99,7 +99,7 @@ public final class PatternTranslator extends AbstractTranslator {
     }
 
     private boolean isNullable(JetTypePattern pattern) {
-        return BindingUtils.getTypeByReference(context().bindingContext(),
+        return BindingUtils.getTypeByReference(bindingContext(),
                 getTypeReference(pattern)).isNullable();
     }
 
@@ -119,7 +119,7 @@ public final class PatternTranslator extends AbstractTranslator {
     @NotNull
     private JsNameRef getClassNameReferenceForTypeReference(@NotNull JetTypeReference typeReference) {
         ClassDescriptor referencedClass = BindingUtils.getClassDescriptorForTypeReference
-                (context().bindingContext(), typeReference);
+                (bindingContext(), typeReference);
         return TranslationUtils.getQualifiedReference(context(), referencedClass);
     }
 

translator/src/org/jetbrains/k2js/translate/expression/StringTemplateTranslator.java

@@ -82,13 +82,13 @@ public final class StringTemplateTranslator extends AbstractTranslator {
         //TODO: duplication
         @Override
         public void visitLiteralStringTemplateEntry(@NotNull JetLiteralStringTemplateEntry entry) {
-            JsStringLiteral stringConstant = context().program().getStringLiteral(entry.getText());
+            JsStringLiteral stringConstant = program().getStringLiteral(entry.getText());
             append(stringConstant);
         }
 
         @Override
         public void visitEscapeStringTemplateEntry(@NotNull JetEscapeStringTemplateEntry entry) {
-            JsStringLiteral escapedValue = context().program().getStringLiteral(entry.getUnescapedValue());
+            JsStringLiteral escapedValue = program().getStringLiteral(entry.getUnescapedValue());
             append(escapedValue);
         }
 

translator/src/org/jetbrains/k2js/translate/expression/WhenTranslator.java

@@ -55,7 +55,7 @@ public class WhenTranslator extends AbstractTranslator {
         super(context);
         this.whenExpression = expression;
         this.expressionToMatch = translateExpressionToMatch(whenExpression);
-        this.dummyCounter = context.declareTemporary(context().program().getNumberLiteral(0));
+        this.dummyCounter = context.declareTemporary(program().getNumberLiteral(0));
         this.result = context.declareTemporary(program().getNullLiteral());
     }
 
@@ -80,7 +80,7 @@ public class WhenTranslator extends AbstractTranslator {
     @NotNull
     private JsStatement surroundWithDummyIf(@NotNull JsStatement entryStatement) {
         JsExpression stepNumberEqualsCurrentEntryNumber = new JsBinaryOperation(JsBinaryOperator.EQ,
-                dummyCounter.reference(), context().program().getNumberLiteral(currentEntryNumber));
+                dummyCounter.reference(), program().getNumberLiteral(currentEntryNumber));
         currentEntryNumber++;
         return new JsIf(stepNumberEqualsCurrentEntryNumber, entryStatement, null);
     }

translator/src/org/jetbrains/k2js/translate/expression/foreach/IteratorForTranslator.java

@@ -71,13 +71,13 @@ public final class IteratorForTranslator extends ForTranslator {
 
     @NotNull
     private JsExpression nextMethodInvocation() {
-        FunctionDescriptor nextFunction = getNextFunction(context().bindingContext(), getLoopRange(expression));
+        FunctionDescriptor nextFunction = getNextFunction(bindingContext(), getLoopRange(expression));
         return translateMethodInvocation(iterator.reference(), nextFunction);
     }
 
     @NotNull
     private JsExpression hasNextMethodInvocation() {
-        CallableDescriptor hasNextFunction = getHasNextCallable(context().bindingContext(), getLoopRange(expression));
+        CallableDescriptor hasNextFunction = getHasNextCallable(bindingContext(), getLoopRange(expression));
         return translateMethodInvocation(iterator.reference(), hasNextFunction);
     }
 
@@ -85,7 +85,7 @@ public final class IteratorForTranslator extends ForTranslator {
     private JsExpression iteratorMethodInvocation() {
         JetExpression rangeExpression = getLoopRange(expression);
         JsExpression range = Translation.translateAsExpression(rangeExpression, context());
-        FunctionDescriptor iteratorFunction = getIteratorFunction(context().bindingContext(), rangeExpression);
+        FunctionDescriptor iteratorFunction = getIteratorFunction(bindingContext(), rangeExpression);
         return translateMethodInvocation(range, iteratorFunction);
     }
 

translator/src/org/jetbrains/k2js/translate/general/AbstractTranslator.java

@@ -18,13 +18,13 @@ package org.jetbrains.k2js.translate.general;
 
 import com.google.dart.compiler.backend.js.ast.JsProgram;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.k2js.translate.context.Aliaser;
 import org.jetbrains.k2js.translate.context.TranslationContext;
 
 /**
  * @author Pavel Talanov
  */
-//TODO: provide helper methods for different parts of context
 public abstract class AbstractTranslator {
 
     @NotNull
@@ -48,4 +48,9 @@ public abstract class AbstractTranslator {
     protected Aliaser aliaser() {
         return context.aliaser();
     }
+
+    @NotNull
+    protected BindingContext bindingContext() {
+        return context.bindingContext();
+    }
 }

translator/src/org/jetbrains/k2js/translate/initializer/ClassInitializerTranslator.java

@@ -73,7 +73,7 @@ public final class ClassInitializerTranslator extends AbstractInitializerTransla
     }
 
     private void mayBeAddCallToSuperMethod() {
-        if (hasAncestorClass(context().bindingContext(), classDeclaration)) {
+        if (hasAncestorClass(bindingContext(), classDeclaration)) {
             JetDelegatorToSuperCall superCall = getSuperCall();
             if (superCall == null) return;
             addCallToSuperMethod(superCall);
@@ -119,7 +119,7 @@ public final class ClassInitializerTranslator extends AbstractInitializerTransla
     @NotNull
     private JsParameter translateParameter(@NotNull JetParameter jetParameter) {
         DeclarationDescriptor parameterDescriptor =
-                getDescriptorForElement(context().bindingContext(), jetParameter);
+                getDescriptorForElement(bindingContext(), jetParameter);
         JsName parameterName = context().getNameForDescriptor(parameterDescriptor);
         JsParameter jsParameter = new JsParameter(parameterName);
         mayBeAddInitializerStatementForProperty(jsParameter, jetParameter);
@@ -129,7 +129,7 @@ public final class ClassInitializerTranslator extends AbstractInitializerTransla
     private void mayBeAddInitializerStatementForProperty(@NotNull JsParameter jsParameter,
                                                          @NotNull JetParameter jetParameter) {
         PropertyDescriptor propertyDescriptor =
-                getPropertyDescriptorForConstructorParameter(context().bindingContext(), jetParameter);
+                getPropertyDescriptorForConstructorParameter(bindingContext(), jetParameter);
         if (propertyDescriptor != null) {
             JsStatement assignmentToBackingFieldExpression = assignmentToBackingField
                     (context(), propertyDescriptor, jsParameter.getName().makeRef());

translator/src/org/jetbrains/k2js/translate/operation/BinaryOperationTranslator.java

@@ -74,7 +74,7 @@ public final class BinaryOperationTranslator extends AbstractTranslator {
         super(context);
         this.expression = expression;
         this.operationDescriptor =
-                getFunctionDescriptorForOperationExpression(context().bindingContext(), expression);
+                getFunctionDescriptorForOperationExpression(bindingContext(), expression);
     }
 
     @NotNull
@@ -125,7 +125,7 @@ public final class BinaryOperationTranslator extends AbstractTranslator {
     private JsExpression translateAsOverloadedBinaryOperation() {
         CallBuilder callBuilder = setReceiverAndArguments();
         ResolvedCall<?> resolvedCall1 =
-                getResolvedCall(context().bindingContext(), expression.getOperationReference());
+                getResolvedCall(bindingContext(), expression.getOperationReference());
         JsExpression result = callBuilder.resolvedCall(resolvedCall1)
                 .type(CallType.NORMAL).translate();
         return mayBeWrapWithNegation(result);

translator/src/org/jetbrains/k2js/translate/operation/IncrementTranslator.java

@@ -79,7 +79,7 @@ public abstract class IncrementTranslator extends AbstractTranslator {
     }
 
     private boolean returnValueIgnored() {
-        return isStatement(context().bindingContext(), expression);
+        return isStatement(bindingContext(), expression);
     }
 
     @NotNull

translator/src/org/jetbrains/k2js/translate/operation/IntrinsicIncrementTranslator.java

@@ -76,7 +76,7 @@ public final class IntrinsicIncrementTranslator extends IncrementTranslator {
     }
 
     public JsBinaryOperation unaryAsBinary(@NotNull JsExpression leftExpression) {
-        JsNumberLiteral oneLiteral = context().program().getNumberLiteral(1);
+        JsNumberLiteral oneLiteral = program().getNumberLiteral(1);
         JetToken token = getOperationToken(expression);
         if (token.equals(JetTokens.PLUSPLUS)) {
             return new JsBinaryOperation(JsBinaryOperator.ADD, leftExpression, oneLiteral);

translator/src/org/jetbrains/k2js/translate/reference/ArrayAccessTranslator.java

@@ -77,7 +77,7 @@ public final class ArrayAccessTranslator extends AccessTranslator {
         return CallBuilder.build(context())
                 .receiver(translateArrayExpression())
                 .args(arguments)
-                .resolvedCall(BindingUtils.getResolvedCall(context().bindingContext(), expression))
+                .resolvedCall(BindingUtils.getResolvedCall(bindingContext(), expression))
                 .descriptor(methodDescriptor)
                 .translate();
     }

translator/src/org/jetbrains/k2js/translate/reference/CallExpressionTranslator.java

@@ -16,6 +16,7 @@
 
 package org.jetbrains.k2js.translate.reference;
 
+import com.google.common.collect.Lists;
 import com.google.dart.compiler.backend.js.ast.JsArrayLiteral;
 import com.google.dart.compiler.backend.js.ast.JsExpression;
 import org.jetbrains.annotations.NotNull;
@@ -27,8 +28,10 @@ import org.jetbrains.jet.lang.resolve.calls.*;
 import org.jetbrains.k2js.translate.context.TranslationContext;
 import org.jetbrains.k2js.translate.general.AbstractTranslator;
 import org.jetbrains.k2js.translate.general.Translation;
+import org.jetbrains.k2js.translate.utils.AnnotationsUtils;
 
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
 
 import static org.jetbrains.k2js.translate.utils.BindingUtils.getDefaultArgument;
@@ -50,20 +53,24 @@ public final class CallExpressionTranslator extends AbstractTranslator {
 
     @NotNull
     private final JetCallExpression expression;
+    @NotNull
+    private final ResolvedCall<?> resolvedCall;
+    private final boolean isNativeFunctionCall;
 
     private CallExpressionTranslator(@NotNull JetCallExpression expression,
                                      @NotNull TranslationContext context) {
         super(context);
         this.expression = expression;
+        this.resolvedCall = getResolvedCallForCallExpression(bindingContext(), expression);
+        this.isNativeFunctionCall = AnnotationsUtils.isNativeObject(resolvedCall.getCandidateDescriptor());
     }
 
     @NotNull
     private JsExpression translate(@Nullable JsExpression receiver,
                                    @NotNull CallType callType) {
-        ResolvedCall<?> resolvedCall = getResolvedCallForCallExpression(context().bindingContext(), expression);
         return CallBuilder.build(context())
                 .receiver(receiver)
-                .callee(getCalleeExpression(resolvedCall))
+                .callee(getCalleeExpression())
                 .args(translateArguments())
                 .resolvedCall(resolvedCall)
                 .type(callType)
@@ -71,7 +78,7 @@ public final class CallExpressionTranslator extends AbstractTranslator {
     }
 
     @Nullable
-    private JsExpression getCalleeExpression(@NotNull ResolvedCall<?> resolvedCall) {
+    private JsExpression getCalleeExpression() {
         if (resolvedCall.getCandidateDescriptor() instanceof ExpressionAsFunctionDescriptor) {
             return Translation.translateAsExpression(getCallee(expression), context());
         }
@@ -81,36 +88,46 @@ public final class CallExpressionTranslator extends AbstractTranslator {
     @NotNull
     private List<JsExpression> translateArguments() {
         List<JsExpression> result = new ArrayList<JsExpression>();
-        ResolvedCall<?> resolvedCall = getResolvedCallForCallExpression(context().bindingContext(), expression);
+        ResolvedCall<?> resolvedCall = getResolvedCallForCallExpression(bindingContext(), expression);
         for (ValueParameterDescriptor parameterDescriptor : resolvedCall.getResultingDescriptor().getValueParameters()) {
             ResolvedValueArgument actualArgument = resolvedCall.getValueArgumentsByIndex().get(parameterDescriptor.getIndex());
-            result.add(translateSingleArgument(actualArgument, parameterDescriptor));
+            result.addAll(translateSingleArgument(actualArgument, parameterDescriptor));
         }
         return result;
     }
 
     @NotNull
-    private JsExpression translateSingleArgument(@NotNull ResolvedValueArgument actualArgument,
+    private List<JsExpression> translateSingleArgument(@NotNull ResolvedValueArgument actualArgument,
-                                                 @NotNull ValueParameterDescriptor parameterDescriptor) {
+                                                       @NotNull ValueParameterDescriptor parameterDescriptor) {
         List<JetExpression> argumentExpressions = actualArgument.getArgumentExpressions();
         if (actualArgument instanceof VarargValueArgument) {
             return translateVarargArgument(argumentExpressions);
         }
         if (actualArgument instanceof DefaultValueArgument) {
-            JetExpression defaultArgument = getDefaultArgument(context().bindingContext(), parameterDescriptor);
+            JetExpression defaultArgument = getDefaultArgument(bindingContext(), parameterDescriptor);
-            return Translation.translateAsExpression(defaultArgument, context());
+            return Arrays.asList(Translation.translateAsExpression(defaultArgument, context()));
         }
         assert actualArgument instanceof ExpressionValueArgument;
         assert argumentExpressions.size() == 1;
-        return Translation.translateAsExpression(argumentExpressions.get(0), context());
+        return Arrays.asList(Translation.translateAsExpression(argumentExpressions.get(0), context()));
     }
 
     @NotNull
-    private JsExpression translateVarargArgument(@NotNull List<JetExpression> arguments) {
+    private List<JsExpression> translateVarargArgument(@NotNull List<JetExpression> arguments) {
-        JsArrayLiteral varargArgument = new JsArrayLiteral();
+        List<JsExpression> translatedArgs = Lists.newArrayList();
         for (JetExpression argument : arguments) {
-            varargArgument.getExpressions().add(Translation.translateAsExpression(argument, context()));
+            translatedArgs.add(Translation.translateAsExpression(argument, context()));
         }
-        return varargArgument;
+        if (isNativeFunctionCall) {
+            return translatedArgs;
+        }
+        return wrapInArrayLiteral(translatedArgs);
+    }
+
+    @NotNull
+    private List<JsExpression> wrapInArrayLiteral(@NotNull List<JsExpression> translatedArgs) {
+        JsArrayLiteral argsWrappedInArray = new JsArrayLiteral();
+        argsWrappedInArray.getExpressions().addAll(translatedArgs);
+        return Arrays.<JsExpression>asList(argsWrappedInArray);
     }
 }