From 5a7e879c0c6d3a327207f1c11a988c62de2c5862 Mon Sep 17 00:00:00 2001 From: Stanislav Erokhin Date: Sun, 15 Nov 2015 22:18:49 +0300 Subject: [PATCH] Convert ExpressionReceiver to kotlin. --- .../JavaNullabilityWarningsChecker.kt | 2 +- .../resolve/DelegatedPropertyResolver.java | 4 +- .../resolve/calls/CallExpressionResolver.java | 2 +- .../kotlin/resolve/calls/CallResolver.java | 2 +- .../kotlin/resolve/calls/CallResolverUtil.kt | 4 +- .../kotlin/resolve/calls/CallTransformer.java | 2 +- .../kotlin/resolve/calls/CandidateResolver.kt | 2 +- .../resolve/calls/GenericCandidateResolver.kt | 2 +- .../kotlin/resolve/calls/resolvedCallUtil.kt | 2 +- .../scopes/receivers/ExpressionReceiver.java | 50 ------------------- .../scopes/receivers/ExpressionReceiver.kt | 36 +++++++++++++ .../BasicExpressionTypingVisitor.java | 4 +- .../expressions/ExpressionTypingUtils.java | 4 +- .../ExpressionTypingVisitorForStatements.java | 2 +- .../calls/AbstractResolvedCallsTest.kt | 2 +- .../kotlin/idea/util/extensionsUtils.kt | 2 +- .../ConvertForEachToForLoopIntention.kt | 2 +- .../psi/patternMatching/KotlinPsiUnifier.kt | 4 +- .../callTranslator/CallInfoExtensions.kt | 2 +- .../callTranslator/CallTranslator.kt | 2 +- 20 files changed, 59 insertions(+), 73 deletions(-) delete mode 100644 compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/receivers/ExpressionReceiver.java create mode 100644 compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/receivers/ExpressionReceiver.kt diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/JavaNullabilityWarningsChecker.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/JavaNullabilityWarningsChecker.kt index 968d70516bf..80ce4f19012 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/JavaNullabilityWarningsChecker.kt +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/JavaNullabilityWarningsChecker.kt @@ -180,7 +180,7 @@ public class JavaNullabilityWarningsChecker : AdditionalTypeChecker { actualMayBeNull -> val reportOn = if (receiverArgument is ExpressionReceiver) - receiverArgument.getExpression() + receiverArgument.expression else c.call.getCalleeExpression() ?: c.call.getCallElement() diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DelegatedPropertyResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DelegatedPropertyResolver.java index 7475c6fdeb8..eaba5464b66 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DelegatedPropertyResolver.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DelegatedPropertyResolver.java @@ -145,7 +145,7 @@ public class DelegatedPropertyResolver { KtPsiFactory psiFactory = KtPsiFactory(delegateExpression); List arguments = Collections.singletonList(createExpressionForProperty(psiFactory)); - ExpressionReceiver receiver = ExpressionReceiver.create(delegateExpression, delegateType, trace.getBindingContext()); + ExpressionReceiver receiver = ExpressionReceiver.Companion.create(delegateExpression, delegateType, trace.getBindingContext()); Pair> resolutionResult = fakeCallResolver.makeAndResolveFakeCallInContext(receiver, context, arguments, PROPERTY_DELEGATED_FUNCTION_NAME, delegateExpression); @@ -261,7 +261,7 @@ public class DelegatedPropertyResolver { } Name functionName = isGet ? GETTER_NAME : SETTER_NAME; - ExpressionReceiver receiver = ExpressionReceiver.create(delegateExpression, delegateType, trace.getBindingContext()); + ExpressionReceiver receiver = ExpressionReceiver.Companion.create(delegateExpression, delegateType, trace.getBindingContext()); Pair> resolutionResult = fakeCallResolver.makeAndResolveFakeCallInContext(receiver, context, arguments, functionName, delegateExpression); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallExpressionResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallExpressionResolver.java index 50ad3770970..3113e02db85 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallExpressionResolver.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallExpressionResolver.java @@ -349,7 +349,7 @@ public class CallExpressionResolver { QualifierReceiver qualifierReceiver = (QualifierReceiver) context.trace.get(BindingContext.QUALIFIER, element.getReceiver()); ReceiverValue receiver = qualifierReceiver == null ? - ExpressionReceiver.create(element.getReceiver(), receiverType, context.trace.getBindingContext()) : + ExpressionReceiver.Companion.create(element.getReceiver(), receiverType, context.trace.getBindingContext()) : qualifierReceiver; boolean lastStage = element.getQualified() == expression; diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolver.java index 23104524e6e..e86f1eb11c3 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolver.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolver.java @@ -315,7 +315,7 @@ public class CallResolver { } KotlinType calleeType = expressionTypingServices.safeGetType( context.scope, calleeExpression, expectedType, context.dataFlowInfo, context.trace); - ExpressionReceiver expressionReceiver = ExpressionReceiver.create(calleeExpression, calleeType, context.trace.getBindingContext()); + ExpressionReceiver expressionReceiver = ExpressionReceiver.Companion.create(calleeExpression, calleeType, context.trace.getBindingContext()); Call call = new CallTransformer.CallForImplicitInvoke(context.call.getExplicitReceiver(), expressionReceiver, context.call); TracingStrategyForInvoke tracingForInvoke = new TracingStrategyForInvoke(calleeExpression, call, calleeType); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolverUtil.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolverUtil.kt index 3fcfdc4c0ae..a250b78debd 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolverUtil.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolverUtil.kt @@ -133,7 +133,7 @@ public fun isInvokeCallOnVariable(call: Call): Boolean { if (call.getCallType() !== Call.CallType.INVOKE) return false val dispatchReceiver = call.getDispatchReceiver() //calleeExpressionAsDispatchReceiver for invoke is always ExpressionReceiver, see CallForImplicitInvoke - val expression = (dispatchReceiver as ExpressionReceiver).getExpression() + val expression = (dispatchReceiver as ExpressionReceiver).expression return expression is KtSimpleNameExpression } @@ -143,7 +143,7 @@ public fun isInvokeCallOnExpressionWithBothReceivers(call: Call): Boolean { } public fun getSuperCallExpression(call: Call): KtSuperExpression? { - return (call.getExplicitReceiver() as? ExpressionReceiver)?.getExpression() as? KtSuperExpression + return (call.getExplicitReceiver() as? ExpressionReceiver)?.expression as? KtSuperExpression } public fun getEffectiveExpectedType(parameterDescriptor: ValueParameterDescriptor, argument: ValueArgument): KotlinType { diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallTransformer.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallTransformer.java index 8d301d0c99b..477a66e0582 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallTransformer.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallTransformer.java @@ -235,7 +235,7 @@ public class CallTransformer { KtExpression calleeExpression = task.call.getCalleeExpression(); if (calleeExpression == null) return Collections.emptyList(); - ExpressionReceiver variableReceiver = ExpressionReceiver.create( + ExpressionReceiver variableReceiver = ExpressionReceiver.Companion.create( calleeExpression, variableResolvedCall.getResultingDescriptor().getType(), context.trace.getBindingContext()); Call functionCall = new CallForImplicitInvoke(context.explicitExtensionReceiverForInvoke, variableReceiver, task.call); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CandidateResolver.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CandidateResolver.kt index d2c5923bc36..dbbce938ff5 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CandidateResolver.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CandidateResolver.kt @@ -285,7 +285,7 @@ public class CandidateResolver( private fun getReceiverSuper(receiver: ReceiverValue): KtSuperExpression? { if (receiver is ExpressionReceiver) { - val expression = receiver.getExpression() + val expression = receiver.expression if (expression is KtSuperExpression) { return expression } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/GenericCandidateResolver.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/GenericCandidateResolver.kt index 0ca8f27361f..9c6be5739c6 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/GenericCandidateResolver.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/GenericCandidateResolver.kt @@ -99,7 +99,7 @@ class GenericCandidateResolver( else receiverArgument.getType() if (receiverArgument is ExpressionReceiver) { - receiverType = updateResultTypeForSmartCasts(receiverType, receiverArgument.getExpression(), context) + receiverType = updateResultTypeForSmartCasts(receiverType, receiverArgument.expression, context) } constraintSystem.addSubtypeConstraint(receiverType, receiverParameter.getType(), RECEIVER_POSITION.position()) } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/resolvedCallUtil.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/resolvedCallUtil.kt index ca126fdd7b1..cfa2f34e1ba 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/resolvedCallUtil.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/resolvedCallUtil.kt @@ -58,7 +58,7 @@ private fun ResolvedCall<*>.hasThisOrNoDispatchReceiver( dispatchReceiverDescriptor = dispatchReceiverValue.getDeclarationDescriptor() } else if (dispatchReceiverValue is ExpressionReceiver && considerExplicitReceivers) { - val expression = KtPsiUtil.deparenthesize(dispatchReceiverValue.getExpression()) + val expression = KtPsiUtil.deparenthesize(dispatchReceiverValue.expression) if (expression is KtThisExpression) { // this.foo() -- explicit receiver dispatchReceiverDescriptor = context.get(BindingContext.REFERENCE_TARGET, expression.getInstanceReference()) diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/receivers/ExpressionReceiver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/receivers/ExpressionReceiver.java deleted file mode 100644 index e86b48ad505..00000000000 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/receivers/ExpressionReceiver.java +++ /dev/null @@ -1,50 +0,0 @@ -/* - * Copyright 2010-2015 JetBrains s.r.o. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.jetbrains.kotlin.resolve.scopes.receivers; - -import org.jetbrains.annotations.NotNull; -import org.jetbrains.kotlin.psi.KtExpression; -import org.jetbrains.kotlin.resolve.BindingContext; -import org.jetbrains.kotlin.types.KotlinType; - -public class ExpressionReceiver extends AbstractReceiverValue implements ReceiverValue { - - public static ExpressionReceiver create( - @NotNull KtExpression expression, - @NotNull KotlinType type, - @NotNull BindingContext bindingContext - ) { - return new ExpressionReceiver(expression, type); - } - - private final KtExpression expression; - - public ExpressionReceiver(@NotNull KtExpression expression, @NotNull KotlinType type) { - super(type); - this.expression = expression; - } - - @NotNull - public KtExpression getExpression() { - return expression; - } - - @Override - public String toString() { - return getType() + " {" + expression + ": " + expression.getText() + "}"; - } -} diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/receivers/ExpressionReceiver.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/receivers/ExpressionReceiver.kt new file mode 100644 index 00000000000..faf54a70814 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/receivers/ExpressionReceiver.kt @@ -0,0 +1,36 @@ +/* + * Copyright 2010-2015 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.kotlin.resolve.scopes.receivers + +import org.jetbrains.kotlin.psi.KtExpression +import org.jetbrains.kotlin.resolve.BindingContext +import org.jetbrains.kotlin.types.KotlinType + +class ExpressionReceiver(val expression: KtExpression, type: KotlinType) : AbstractReceiverValue(type), ReceiverValue { + + override fun toString() = "$type {$expression: ${expression.text}}" + + companion object { + + fun create( + expression: KtExpression, + type: KotlinType, + bindingContext: BindingContext): ExpressionReceiver { + return ExpressionReceiver(expression, type) + } + } +} diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java index 9f4248dea16..c03464a8ba2 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java @@ -760,7 +760,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { // Type check the base expression KotlinTypeInfo typeInfo = facade.safeGetTypeInfo(baseExpression, context); KotlinType type = ExpressionTypingUtils.safeGetType(typeInfo); - ExpressionReceiver receiver = ExpressionReceiver.create(baseExpression, type, context.trace.getBindingContext()); + ExpressionReceiver receiver = ExpressionReceiver.Companion.create(baseExpression, type, context.trace.getBindingContext()); Call call = CallMaker.makeCall(receiver, expression); @@ -1495,7 +1495,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { KotlinType arrayType = ExpressionTypingUtils.safeGetType(arrayTypeInfo); ExpressionTypingContext context = oldContext.replaceDataFlowInfo(arrayTypeInfo.getDataFlowInfo()); - ExpressionReceiver receiver = ExpressionReceiver.create(arrayExpression, arrayType, context.trace.getBindingContext()); + ExpressionReceiver receiver = ExpressionReceiver.Companion.create(arrayExpression, arrayType, context.trace.getBindingContext()); if (!isGet) assert rightHandSide != null; Call call = isGet diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingUtils.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingUtils.java index b8bcd346681..9a86dc06bfc 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingUtils.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingUtils.java @@ -79,7 +79,7 @@ public class ExpressionTypingUtils { ) { KotlinType type = facade.getTypeInfo(expression, context).getType(); if (type == null) return null; - return ExpressionReceiver.create(expression, type, context.trace.getBindingContext()); + return ExpressionReceiver.Companion.create(expression, type, context.trace.getBindingContext()); } @NotNull @@ -89,7 +89,7 @@ public class ExpressionTypingUtils { ExpressionTypingContext context ) { KotlinType type = safeGetType(facade.safeGetTypeInfo(expression, context)); - return ExpressionReceiver.create(expression, type, context.trace.getBindingContext()); + return ExpressionReceiver.Companion.create(expression, type, context.trace.getBindingContext()); } @NotNull diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingVisitorForStatements.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingVisitorForStatements.java index 8a9e5efef8f..d32a45be793 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingVisitorForStatements.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingVisitorForStatements.java @@ -250,7 +250,7 @@ public class ExpressionTypingVisitorForStatements extends ExpressionTypingVisito temporary.commit(); return rightInfo.clearType(); } - ExpressionReceiver receiver = ExpressionReceiver.create(left, leftType, context.trace.getBindingContext()); + ExpressionReceiver receiver = ExpressionReceiver.Companion.create(left, leftType, context.trace.getBindingContext()); // We check that defined only one of '+=' and '+' operations, and call it (in the case '+' we then also assign) // Check for '+=' diff --git a/compiler/tests/org/jetbrains/kotlin/resolve/calls/AbstractResolvedCallsTest.kt b/compiler/tests/org/jetbrains/kotlin/resolve/calls/AbstractResolvedCallsTest.kt index f91b45039ca..7d17041e7dc 100644 --- a/compiler/tests/org/jetbrains/kotlin/resolve/calls/AbstractResolvedCallsTest.kt +++ b/compiler/tests/org/jetbrains/kotlin/resolve/calls/AbstractResolvedCallsTest.kt @@ -76,7 +76,7 @@ public abstract class AbstractResolvedCallsTest : KotlinLiteFixture() { } private fun ReceiverValue.getText() = when (this) { - is ExpressionReceiver -> "${getExpression().getText()} {${getType()}}" + is ExpressionReceiver -> "${expression.getText()} {${getType()}}" is ClassReceiver -> "Class{${getType()}}" is ExtensionReceiver -> "${getType()}Ext{${getDeclarationDescriptor().getText()}}" else -> toString() diff --git a/idea/ide-common/src/org/jetbrains/kotlin/idea/util/extensionsUtils.kt b/idea/ide-common/src/org/jetbrains/kotlin/idea/util/extensionsUtils.kt index 4eb27803d5f..b9ab4b341f1 100644 --- a/idea/ide-common/src/org/jetbrains/kotlin/idea/util/extensionsUtils.kt +++ b/idea/ide-common/src/org/jetbrains/kotlin/idea/util/extensionsUtils.kt @@ -105,7 +105,7 @@ public fun TCallable.substituteExtensionIfCalla public fun ReceiverValue.getThisReceiverOwner(bindingContext: BindingContext): DeclarationDescriptor? { return when (this) { is ExpressionReceiver -> { - val thisRef = (KtPsiUtil.deparenthesize(this.getExpression()) as? KtThisExpression)?.getInstanceReference() ?: return null + val thisRef = (KtPsiUtil.deparenthesize(this.expression) as? KtThisExpression)?.getInstanceReference() ?: return null bindingContext[BindingContext.REFERENCE_TARGET, thisRef] } diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertForEachToForLoopIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertForEachToForLoopIntention.kt index 9dc6b7f2ef1..418e3978089 100644 --- a/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertForEachToForLoopIntention.kt +++ b/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertForEachToForLoopIntention.kt @@ -66,7 +66,7 @@ public class ConvertForEachToForLoopIntention : SelfTargetingOffsetIndependentIn val receiver = resolvedCall.getCall().getExplicitReceiver() as? ExpressionReceiver ?: return null val argument = resolvedCall.getCall().getValueArguments().singleOrNull() ?: return null val functionLiteral = argument.getArgumentExpression() as? KtFunctionLiteralExpression ?: return null - return Data(expression, receiver.getExpression(), functionLiteral) + return Data(expression, receiver.expression, functionLiteral) } private fun generateLoop(functionLiteral: KtFunctionLiteralExpression, receiver: KtExpression): KtExpression { diff --git a/idea/src/org/jetbrains/kotlin/idea/util/psi/patternMatching/KotlinPsiUnifier.kt b/idea/src/org/jetbrains/kotlin/idea/util/psi/patternMatching/KotlinPsiUnifier.kt index 0abddf62cc6..c59c428ee65 100644 --- a/idea/src/org/jetbrains/kotlin/idea/util/psi/patternMatching/KotlinPsiUnifier.kt +++ b/idea/src/org/jetbrains/kotlin/idea/util/psi/patternMatching/KotlinPsiUnifier.kt @@ -131,7 +131,7 @@ public class KotlinPsiUnifier( private fun matchReceivers(rv1: ReceiverValue, rv2: ReceiverValue): Boolean { return when { rv1 is ExpressionReceiver && rv2 is ExpressionReceiver -> - doUnify(rv1.getExpression(), rv2.getExpression()) == MATCHED + doUnify(rv1.expression, rv2.expression) == MATCHED rv1 is ThisReceiver && rv2 is ThisReceiver -> matchDescriptors(rv1.getDeclarationDescriptor(), rv2.getDeclarationDescriptor()) @@ -211,7 +211,7 @@ public class KotlinPsiUnifier( null to null } - val thisExpression = explicitReceiver?.getExpression() as? KtThisExpression + val thisExpression = explicitReceiver?.expression as? KtThisExpression if (implicitReceiver == null || thisExpression == null) return false return matchDescriptors( diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/callTranslator/CallInfoExtensions.kt b/js/js.translator/src/org/jetbrains/kotlin/js/translate/callTranslator/CallInfoExtensions.kt index 6ed82a07f30..ea5be85ddec 100644 --- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/callTranslator/CallInfoExtensions.kt +++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/callTranslator/CallInfoExtensions.kt @@ -41,7 +41,7 @@ fun CallInfo.isNative(): Boolean = AnnotationsUtils.isNativeObject(callableDescr fun CallInfo.isSuperInvocation(): Boolean { val dispatchReceiver = resolvedCall.getDispatchReceiver() - return dispatchReceiver is ExpressionReceiver && dispatchReceiver.getExpression() is KtSuperExpression + return dispatchReceiver is ExpressionReceiver && dispatchReceiver.expression is KtSuperExpression } val VariableAccessInfo.variableDescriptor: VariableDescriptor diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/callTranslator/CallTranslator.kt b/js/js.translator/src/org/jetbrains/kotlin/js/translate/callTranslator/CallTranslator.kt index 2bcaa26d989..751345edb80 100644 --- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/callTranslator/CallTranslator.kt +++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/callTranslator/CallTranslator.kt @@ -125,7 +125,7 @@ fun computeExplicitReceiversForInvoke( assert(explicitReceivers.extensionReceiver == null) { "'Invoke' call must have one receiver: $callElement" } fun translateReceiverAsExpression(receiver: ReceiverValue): JsExpression? = - (receiver as? ExpressionReceiver)?.let { Translation.translateAsExpression(it.getExpression(), context) } + (receiver as? ExpressionReceiver)?.let { Translation.translateAsExpression(it.expression, context) } val dispatchReceiver = resolvedCall.getDispatchReceiver() val extensionReceiver = resolvedCall.getExtensionReceiver()