JS: small fixes after conversion

2015-03-16 20:10:16 +03:00
parent f0c2aa9eb2
commit 0a3ed7f12e
3 changed files with 48 additions and 49 deletions
@@ -74,7 +74,7 @@ fun VariableAccessInfo.constructAccessExpression(ref: JsExpression): JsExpressio
 val FunctionCallInfo.functionName: JsName
    get() = context.getNameForDescriptor(callableDescriptor)

-fun FunctionCallInfo.hasSpreadOperator(): Boolean = argumentsInfo.isHasSpreadOperator()
+fun FunctionCallInfo.hasSpreadOperator(): Boolean = argumentsInfo.hasSpreadOperator

 fun TranslationContext.aliasOrValue(callableDescriptor: CallableDescriptor, value: (CallableDescriptor) -> JsExpression): JsExpression {
    val alias = getAliasForDescriptor(callableDescriptor)
@@ -51,9 +51,9 @@ public fun addReceiverToArgs(receiver: JsExpression, arguments: List<JsExpressio
 object DefaultFunctionCallCase : FunctionCallCase {
    // TODO: refactor after fix ArgumentsInfo - duplicate code
    private fun nativeSpreadFunWithDispatchOrExtensionReceiver(argumentsInfo: CallArgumentTranslator.ArgumentsInfo, functionName: JsName): JsExpression {
-        val cachedReceiver = argumentsInfo.getCachedReceiver()!!
+        val cachedReceiver = argumentsInfo.cachedReceiver!!
        val functionCallRef = Namer.getFunctionApplyRef(JsNameRef(functionName, cachedReceiver.assignmentExpression()))
-        return JsInvocation(functionCallRef, argumentsInfo.getTranslateArguments())
+        return JsInvocation(functionCallRef, argumentsInfo.translateArguments)
    }

    fun buildDefaultCallWithDispatchReceiver(argumentsInfo: CallArgumentTranslator.ArgumentsInfo,
@@ -65,7 +65,7 @@ object DefaultFunctionCallCase : FunctionCallCase {
            return nativeSpreadFunWithDispatchOrExtensionReceiver(argumentsInfo, functionName)
        }
        val functionRef = JsNameRef(functionName, dispatchReceiver)
-        return JsInvocation(functionRef, argumentsInfo.getTranslateArguments())
+        return JsInvocation(functionRef, argumentsInfo.translateArguments)
    }

    fun buildDefaultCallWithoutReceiver(context: TranslationContext,
@@ -76,17 +76,17 @@ object DefaultFunctionCallCase : FunctionCallCase {
                                        hasSpreadOperator: Boolean): JsExpression {
        if (isNative && hasSpreadOperator) {
            val functionCallRef = Namer.getFunctionApplyRef(JsNameRef(functionName))
-            return JsInvocation(functionCallRef, argumentsInfo.getTranslateArguments())
+            return JsInvocation(functionCallRef, argumentsInfo.translateArguments)
        }
        if (isNative) {
-            return JsInvocation(JsNameRef(functionName), argumentsInfo.getTranslateArguments())
+            return JsInvocation(JsNameRef(functionName), argumentsInfo.translateArguments)
        }

        val functionRef = context.aliasOrValue(callableDescriptor) {
            val qualifierForFunction = context.getQualifierForDescriptor(it)
            JsNameRef(functionName, qualifierForFunction)
        }
-        return JsInvocation(functionRef, argumentsInfo.getTranslateArguments())
+        return JsInvocation(functionRef, argumentsInfo.translateArguments)
    }

    override fun FunctionCallInfo.noReceivers(): JsExpression {
@@ -102,7 +102,7 @@ object DefaultFunctionCallCase : FunctionCallCase {
            return nativeSpreadFunWithDispatchOrExtensionReceiver(argumentsInfo, functionName)
        }
        if (isNative()) {
-            return JsInvocation(JsNameRef(functionName, extensionReceiver), argumentsInfo.getTranslateArguments())
+            return JsInvocation(JsNameRef(functionName, extensionReceiver), argumentsInfo.translateArguments)
        }

        val functionRef = context.aliasOrValue(callableDescriptor) {
@@ -118,20 +118,20 @@ object DefaultFunctionCallCase : FunctionCallCase {
                    functionRef
                }

-        return JsInvocation(referenceToCall, addReceiverToArgs(extensionReceiver!!, argumentsInfo.getTranslateArguments()))
+        return JsInvocation(referenceToCall, addReceiverToArgs(extensionReceiver!!, argumentsInfo.translateArguments))
    }

    override fun FunctionCallInfo.bothReceivers(): JsExpression {
        // TODO: think about crazy case: spreadOperator + native
        val functionRef = JsNameRef(functionName, dispatchReceiver!!)
-        return JsInvocation(functionRef, addReceiverToArgs(extensionReceiver!!, argumentsInfo.getTranslateArguments()))
+        return JsInvocation(functionRef, addReceiverToArgs(extensionReceiver!!, argumentsInfo.translateArguments))
    }
 }


 object DelegateFunctionIntrinsic : DelegateIntrinsic<FunctionCallInfo> {
    override fun FunctionCallInfo.getArgs(): List<JsExpression> {
-        return argumentsInfo.getTranslateArguments()
+        return argumentsInfo.translateArguments
    }
    override fun FunctionCallInfo.getDescriptor(): CallableDescriptor {
        return callableDescriptor
@@ -149,17 +149,17 @@ abstract class AnnotatedAsNativeXCallCase(val annotation: PredefinedAnnotation)

 object NativeInvokeCallCase : AnnotatedAsNativeXCallCase(PredefinedAnnotation.NATIVE_INVOKE) {
    override fun translateCall(receiver: JsExpression, argumentsInfo: CallArgumentTranslator.ArgumentsInfo) =
-            JsInvocation(receiver, argumentsInfo.getTranslateArguments())
+            JsInvocation(receiver, argumentsInfo.translateArguments)
 }

 object NativeGetterCallCase : AnnotatedAsNativeXCallCase(PredefinedAnnotation.NATIVE_GETTER) {
    override fun translateCall(receiver: JsExpression, argumentsInfo: CallArgumentTranslator.ArgumentsInfo) =
-            JsArrayAccess(receiver, argumentsInfo.getTranslateArguments()[0])
+            JsArrayAccess(receiver, argumentsInfo.translateArguments[0])
 }

 object NativeSetterCallCase : AnnotatedAsNativeXCallCase(PredefinedAnnotation.NATIVE_SETTER) {
    override fun translateCall(receiver: JsExpression, argumentsInfo: CallArgumentTranslator.ArgumentsInfo): JsExpression {
-        val args = argumentsInfo.getTranslateArguments()
+        val args = argumentsInfo.translateArguments
        return JsAstUtils.assignment(JsArrayAccess(receiver, args[0]), args[1])
    }
 }
@@ -183,7 +183,7 @@ object InvokeIntrinsic : FunctionCallCase {
    }

    override fun FunctionCallInfo.dispatchReceiver(): JsExpression {
-        return JsInvocation(dispatchReceiver, argumentsInfo.getTranslateArguments())
+        return JsInvocation(dispatchReceiver, argumentsInfo.translateArguments)
    }

    /**
@@ -200,7 +200,7 @@ object InvokeIntrinsic : FunctionCallCase {
     *      extLambda.call(obj, some, args)
     */
    override fun FunctionCallInfo.bothReceivers(): JsExpression {
-        return JsInvocation(Namer.getFunctionCallRef(dispatchReceiver!!), addReceiverToArgs(extensionReceiver!!, argumentsInfo.getTranslateArguments()))
+        return JsInvocation(Namer.getFunctionCallRef(dispatchReceiver!!), addReceiverToArgs(extensionReceiver!!, argumentsInfo.translateArguments))
    }
 }

@@ -214,7 +214,7 @@ object ConstructorCallCase : FunctionCallCase {

        val functionRef = if (isNative()) fqName else context.aliasOrValue(callableDescriptor) { fqName }

-        return JsNew(functionRef, argumentsInfo.getTranslateArguments())
+        return JsNew(functionRef, argumentsInfo.translateArguments)
    }
 }

@@ -227,7 +227,7 @@ object SuperCallCase : FunctionCallCase {
        // TODO: spread operator
        val prototypeClass = JsNameRef(Namer.getPrototypeName(), dispatchReceiver!!)
        val functionRef = Namer.getFunctionCallRef(JsNameRef(functionName, prototypeClass))
-        return JsInvocation(functionRef, addReceiverToArgs(JsLiteral.THIS, argumentsInfo.getTranslateArguments()))
+        return JsInvocation(functionRef, addReceiverToArgs(JsLiteral.THIS, argumentsInfo.translateArguments))
    }
 }

@@ -236,7 +236,7 @@ object DynamicInvokeAndBracketAccessCallCase : FunctionCallCase {
            callInfo.resolvedCall.getCall().getCallType() != Call.CallType.DEFAULT && callInfo.callableDescriptor.isDynamic()

    override fun FunctionCallInfo.dispatchReceiver(): JsExpression {
-        val arguments = argumentsInfo.getTranslateArguments()
+        val arguments = argumentsInfo.translateArguments
        val callType = resolvedCall.getCall().getCallType()
        return when (callType) {
            Call.CallType.INVOKE ->
@@ -264,7 +264,7 @@ object DynamicOperatorCallCase : FunctionCallCase {
        val callElement = resolvedCall.getCall().getCallElement() as JetOperationExpression
        val operationToken = PsiUtils.getOperationToken(callElement)

-        val arguments = argumentsInfo.getTranslateArguments()
+        val arguments = argumentsInfo.translateArguments

        return when (callElement) {
            is JetBinaryExpression -> {
@@ -33,38 +33,37 @@ import org.jetbrains.kotlin.resolve.calls.model.*

 import java.util.ArrayList
 import java.util.Collections
+import kotlin.platform.platformStatic

-public class CallArgumentTranslator private(private val resolvedCall: ResolvedCall<*>, private val receiver: JsExpression?, context: TranslationContext) : AbstractTranslator(context) {
+public class CallArgumentTranslator private (
+        private val resolvedCall: ResolvedCall<*>,
+        private val receiver: JsExpression?,
+        context: TranslationContext
+) : AbstractTranslator(context) {

-    public class ArgumentsInfo(public val translateArguments: List<JsExpression>, private val hasSpreadOperator: Boolean, public val cachedReceiver: TemporaryConstVariable) {
-
-        public fun isHasSpreadOperator(): Boolean {
-            return hasSpreadOperator
-        }
-    }
+    public class ArgumentsInfo(
+            public val translateArguments: List<JsExpression>,
+            public val hasSpreadOperator: Boolean,
+            public val cachedReceiver: TemporaryConstVariable?
+    )

    private enum class ArgumentsKind {
        HAS_EMPTY_EXPRESSION_ARGUMENT
        HAS_NOT_EMPTY_EXPRESSION_ARGUMENT
    }

-    private val isNativeFunctionCall: Boolean
+    private val isNativeFunctionCall = AnnotationsUtils.isNativeObject(resolvedCall.getCandidateDescriptor())

-    {
-        this.isNativeFunctionCall = AnnotationsUtils.isNativeObject(resolvedCall.getCandidateDescriptor())
-    }
+    private fun removeLastUndefinedArguments(result: MutableList<JsExpression>) {
+        var i = result.size() - 1

-    private fun removeLastUndefinedArguments(result: List<JsExpression>) {
-        var i: Int
-        run {
-            i = result.size() - 1
-            while (i >= 0) {
-                if (result.get(i) != context().namer().getUndefinedExpression()) {
-                    break
-                }
-                i--
+        while (i >= 0) {
+            if (result.get(i) != context().namer().getUndefinedExpression()) {
+                break
            }
+            i--
        }
+
        result.subList(i + 1, result.size()).clear()
    }

@@ -97,15 +96,13 @@ public class CallArgumentTranslator private(private val resolvedCall: ResolvedCa
                val arguments = actualArgument.getArguments()

                val size = arguments.size()
-                run {
-                    var i = 0
-                    while (i != size) {
-                        if (arguments.get(i).getSpreadElement() != null) {
-                            hasSpreadOperator = true
-                            break
-                        }
-                        ++i
+                var i = 0
+                while (i != size) {
+                    if (arguments.get(i).getSpreadElement() != null) {
+                        hasSpreadOperator = true
+                        break
                    }
+                    ++i
                }

                if (hasSpreadOperator) {
@@ -149,7 +146,7 @@ public class CallArgumentTranslator private(private val resolvedCall: ResolvedCa
                concatArguments!!.add(0, JsArrayLiteral(argsBeforeVararg))
            }

-            result = SmartList(concatArgumentsIfNeeded(concatArguments))
+            result = SmartList(concatArgumentsIfNeeded(concatArguments!!))

            if (receiver != null) {
                cachedReceiver = context().getOrDeclareTemporaryConstVariable(receiver)
@@ -166,10 +163,12 @@ public class CallArgumentTranslator private(private val resolvedCall: ResolvedCa

    companion object {

+        platformStatic
        public fun translate(resolvedCall: ResolvedCall<*>, receiver: JsExpression?, context: TranslationContext): ArgumentsInfo {
            return translate(resolvedCall, receiver, context, context.dynamicContext().jsBlock())
        }

+        platformStatic
        public fun translate(resolvedCall: ResolvedCall<*>, receiver: JsExpression?, context: TranslationContext, block: JsBlock): ArgumentsInfo {
            val innerContext = context.innerBlock(block)
            val argumentTranslator = CallArgumentTranslator(resolvedCall, receiver, innerContext)