diff --git a/compiler/backend-common/src/org/jetbrains/kotlin/backend/common/CodegenUtil.java b/compiler/backend-common/src/org/jetbrains/kotlin/backend/common/CodegenUtil.java index 92e576a916b..b6b55e1067d 100644 --- a/compiler/backend-common/src/org/jetbrains/kotlin/backend/common/CodegenUtil.java +++ b/compiler/backend-common/src/org/jetbrains/kotlin/backend/common/CodegenUtil.java @@ -17,7 +17,6 @@ package org.jetbrains.kotlin.backend.common; import com.intellij.openapi.editor.Document; -import com.intellij.openapi.util.TextRange; import com.intellij.psi.PsiElement; import com.intellij.psi.PsiFile; import org.jetbrains.annotations.NotNull; @@ -29,7 +28,7 @@ import org.jetbrains.kotlin.name.Name; import org.jetbrains.kotlin.psi.*; import org.jetbrains.kotlin.resolve.BindingContext; import org.jetbrains.kotlin.resolve.DescriptorUtils; -import org.jetbrains.kotlin.resolve.calls.CallResolverUtil; +import org.jetbrains.kotlin.resolve.calls.callResolverUtil.CallResolverUtilPackage; import org.jetbrains.kotlin.resolve.calls.callUtil.CallUtilPackage; import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall; import org.jetbrains.kotlin.types.JetType; @@ -62,7 +61,7 @@ public class CodegenUtil { ) { Collection functions = owner.getDefaultType().getMemberScope().getFunctions(name); for (FunctionDescriptor function : functions) { - if (!CallResolverUtil.isOrOverridesSynthesized(function) + if (!CallResolverUtilPackage.isOrOverridesSynthesized(function) && function.getTypeParameters().isEmpty() && valueParameterClassesMatch(function.getValueParameters(), Arrays.asList(valueParameterClassifiers)) && rawTypeMatches(function.getReturnType(), returnedClassifier)) { diff --git a/compiler/backend-common/src/org/jetbrains/kotlin/backend/common/bridges/impl.kt b/compiler/backend-common/src/org/jetbrains/kotlin/backend/common/bridges/impl.kt index 63399e7628a..06b84441db6 100644 --- a/compiler/backend-common/src/org/jetbrains/kotlin/backend/common/bridges/impl.kt +++ b/compiler/backend-common/src/org/jetbrains/kotlin/backend/common/bridges/impl.kt @@ -21,7 +21,7 @@ import org.jetbrains.kotlin.descriptors.FunctionDescriptor import org.jetbrains.kotlin.descriptors.Modality import org.jetbrains.kotlin.resolve.DescriptorUtils import org.jetbrains.kotlin.resolve.OverrideResolver -import org.jetbrains.kotlin.resolve.calls.CallResolverUtil +import org.jetbrains.kotlin.resolve.calls.callResolverUtil.isOrOverridesSynthesized public fun generateBridgesForFunctionDescriptor( descriptor: FunctionDescriptor, @@ -69,7 +69,7 @@ private data class DescriptorBasedFunctionHandle(val descriptor: FunctionDescrip */ public fun findTraitImplementation(descriptor: CallableMemberDescriptor): CallableMemberDescriptor? { if (descriptor.getKind().isReal()) return null - if (CallResolverUtil.isOrOverridesSynthesized(descriptor)) return null + if (isOrOverridesSynthesized(descriptor)) return null val implementation = findImplementationFromInterface(descriptor) ?: return null val immediateConcreteSuper = firstSuperMethodFromKotlin(descriptor, implementation) ?: return null diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java index 384cfe537f0..3bff774576d 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java @@ -60,7 +60,7 @@ import org.jetbrains.kotlin.resolve.BindingContextUtils; import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils; import org.jetbrains.kotlin.resolve.DescriptorUtils; import org.jetbrains.kotlin.resolve.annotations.AnnotationsPackage; -import org.jetbrains.kotlin.resolve.calls.CallResolverUtil; +import org.jetbrains.kotlin.resolve.calls.callResolverUtil.CallResolverUtilPackage; import org.jetbrains.kotlin.resolve.calls.model.*; import org.jetbrains.kotlin.resolve.calls.util.CallMaker; import org.jetbrains.kotlin.resolve.calls.util.FakeCallableDescriptorForObject; @@ -2330,7 +2330,7 @@ public class ExpressionCodegen extends JetVisitor implem @NotNull public StackValue invokeFunction(@NotNull Call call, @NotNull ResolvedCall resolvedCall, @NotNull StackValue receiver) { FunctionDescriptor fd = accessibleFunctionDescriptor(resolvedCall); - JetSuperExpression superCallExpression = CallResolverUtil.getSuperCallExpression(call); + JetSuperExpression superCallExpression = CallResolverUtilPackage.getSuperCallExpression(call); boolean superCall = superCallExpression != null; if (superCall && !isInterface(fd.getContainingDeclaration())) { diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionCodegen.java index c0f2e76d315..cd7016c3f68 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionCodegen.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionCodegen.java @@ -42,7 +42,7 @@ import org.jetbrains.kotlin.resolve.BindingContext; import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils; import org.jetbrains.kotlin.resolve.DescriptorUtils; import org.jetbrains.kotlin.resolve.annotations.AnnotationsPackage; -import org.jetbrains.kotlin.resolve.calls.CallResolverUtil; +import org.jetbrains.kotlin.resolve.calls.callResolverUtil.CallResolverUtilPackage; import org.jetbrains.kotlin.resolve.constants.ArrayValue; import org.jetbrains.kotlin.resolve.constants.CompileTimeConstant; import org.jetbrains.kotlin.resolve.constants.KClassValue; @@ -502,7 +502,7 @@ public class FunctionCodegen { if (isMethodOfAny(descriptor)) return; // If the function doesn't have a physical declaration among super-functions, it's a SAM adapter or alike and doesn't need bridges - if (CallResolverUtil.isOrOverridesSynthesized(descriptor)) return; + if (CallResolverUtilPackage.isOrOverridesSynthesized(descriptor)) return; Set> bridgesToGenerate = BridgesPackage.generateBridgesForFunctionDescriptor( descriptor, diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/ImplementationBodyCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/ImplementationBodyCodegen.java index 8e43cb0b89b..83258ee3ce4 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/ImplementationBodyCodegen.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/ImplementationBodyCodegen.java @@ -49,7 +49,7 @@ import org.jetbrains.kotlin.resolve.BindingContext; import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils; import org.jetbrains.kotlin.resolve.DescriptorUtils; import org.jetbrains.kotlin.resolve.annotations.AnnotationsPackage; -import org.jetbrains.kotlin.resolve.calls.CallResolverUtil; +import org.jetbrains.kotlin.resolve.calls.callResolverUtil.CallResolverUtilPackage; import org.jetbrains.kotlin.resolve.calls.callUtil.CallUtilPackage; import org.jetbrains.kotlin.resolve.calls.model.DefaultValueArgument; import org.jetbrains.kotlin.resolve.calls.model.ExpressionValueArgument; @@ -403,7 +403,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { private boolean isGenericToArrayPresent() { Collection functions = descriptor.getDefaultType().getMemberScope().getFunctions(Name.identifier("toArray")); for (FunctionDescriptor function : functions) { - if (CallResolverUtil.isOrOverridesSynthesized(function)) { + if (CallResolverUtilPackage.isOrOverridesSynthesized(function)) { continue; } diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/calls/checkers/TraitDefaultMethodCallChecker.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/calls/checkers/TraitDefaultMethodCallChecker.kt index bb556a97549..647447207fe 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/calls/checkers/TraitDefaultMethodCallChecker.kt +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/calls/checkers/TraitDefaultMethodCallChecker.kt @@ -22,7 +22,7 @@ import org.jetbrains.kotlin.descriptors.ClassifierDescriptor import org.jetbrains.kotlin.load.java.descriptors.JavaClassDescriptor import org.jetbrains.kotlin.psi.JetExpression import org.jetbrains.kotlin.resolve.DescriptorUtils -import org.jetbrains.kotlin.resolve.calls.CallResolverUtil +import org.jetbrains.kotlin.resolve.calls.callResolverUtil.getSuperCallExpression import org.jetbrains.kotlin.resolve.calls.checkers.CallChecker import org.jetbrains.kotlin.resolve.calls.context.BasicCallResolutionContext import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall @@ -31,8 +31,7 @@ import org.jetbrains.kotlin.resolve.jvm.diagnostics.ErrorsJvm public class TraitDefaultMethodCallChecker : CallChecker { override fun check(resolvedCall: ResolvedCall, context: BasicCallResolutionContext) { - val jetSuperExpression = CallResolverUtil.getSuperCallExpression(resolvedCall.getCall()) - if (jetSuperExpression == null) return + if (getSuperCallExpression(resolvedCall.getCall()) == null) return val targetDescriptor = resolvedCall.getResultingDescriptor().getOriginal() val containerDescriptor = targetDescriptor.getContainingDeclaration() diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/OverrideResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/OverrideResolver.java index e9400dff332..2d70bbd2730 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/OverrideResolver.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/OverrideResolver.java @@ -35,7 +35,7 @@ import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor; import org.jetbrains.kotlin.lexer.JetTokens; import org.jetbrains.kotlin.name.Name; import org.jetbrains.kotlin.psi.*; -import org.jetbrains.kotlin.resolve.calls.CallResolverUtil; +import org.jetbrains.kotlin.resolve.calls.callResolverUtil.CallResolverUtilPackage; import org.jetbrains.kotlin.resolve.dataClassUtils.DataClassUtilsPackage; import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue; import org.jetbrains.kotlin.types.*; @@ -361,7 +361,7 @@ public class OverrideResolver { @NotNull List concreteOverridden ) { for (CallableMemberDescriptor overridden : allOverriddenDeclarations) { - if (!CallResolverUtil.isOrOverridesSynthesized(overridden)) { + if (!CallResolverUtilPackage.isOrOverridesSynthesized(overridden)) { if (overridden.getModality() == Modality.ABSTRACT) { abstractOverridden.add(overridden); } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/ArgumentTypeResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/ArgumentTypeResolver.java index 6d57f4c0e68..68c09c6bad1 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/ArgumentTypeResolver.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/ArgumentTypeResolver.java @@ -24,6 +24,7 @@ import org.jetbrains.kotlin.descriptors.annotations.Annotations; import org.jetbrains.kotlin.diagnostics.Errors; import org.jetbrains.kotlin.psi.*; import org.jetbrains.kotlin.resolve.*; +import org.jetbrains.kotlin.resolve.calls.callResolverUtil.ResolveArgumentsMode; import org.jetbrains.kotlin.resolve.calls.callUtil.CallUtilPackage; import org.jetbrains.kotlin.resolve.calls.context.CallResolutionContext; import org.jetbrains.kotlin.resolve.calls.context.CheckValueArgumentsMode; @@ -50,9 +51,8 @@ import java.util.Collections; import java.util.List; import static org.jetbrains.kotlin.resolve.BindingContextUtils.getRecordedTypeInfo; -import static org.jetbrains.kotlin.resolve.calls.CallResolverUtil.ResolveArgumentsMode; -import static org.jetbrains.kotlin.resolve.calls.CallResolverUtil.ResolveArgumentsMode.RESOLVE_FUNCTION_ARGUMENTS; -import static org.jetbrains.kotlin.resolve.calls.CallResolverUtil.ResolveArgumentsMode.SHAPE_FUNCTION_ARGUMENTS; +import static org.jetbrains.kotlin.resolve.calls.callResolverUtil.ResolveArgumentsMode.RESOLVE_FUNCTION_ARGUMENTS; +import static org.jetbrains.kotlin.resolve.calls.callResolverUtil.ResolveArgumentsMode.SHAPE_FUNCTION_ARGUMENTS; import static org.jetbrains.kotlin.resolve.calls.context.ContextDependency.DEPENDENT; import static org.jetbrains.kotlin.resolve.calls.context.ContextDependency.INDEPENDENT; import static org.jetbrains.kotlin.resolve.calls.inference.InferencePackage.createTypeForFunctionPlaceholder; diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallCompleter.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallCompleter.kt index a06e16920ab..9bda02e0631 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallCompleter.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallCompleter.kt @@ -23,13 +23,12 @@ import org.jetbrains.kotlin.resolve.BindingContext.CONSTRAINT_SYSTEM_COMPLETER import org.jetbrains.kotlin.resolve.BindingContextUtils import org.jetbrains.kotlin.resolve.BindingTrace import org.jetbrains.kotlin.resolve.TemporaryBindingTrace -import org.jetbrains.kotlin.resolve.calls.CallResolverUtil.ResolveArgumentsMode.RESOLVE_FUNCTION_ARGUMENTS -import org.jetbrains.kotlin.resolve.calls.CallResolverUtil.getEffectiveExpectedType -import org.jetbrains.kotlin.resolve.calls.callUtil.getCall +import org.jetbrains.kotlin.resolve.calls.callResolverUtil.ResolveArgumentsMode.RESOLVE_FUNCTION_ARGUMENTS +import org.jetbrains.kotlin.resolve.calls.callResolverUtil.getEffectiveExpectedType +import org.jetbrains.kotlin.resolve.calls.callResolverUtil.isInvokeCallOnVariable import org.jetbrains.kotlin.resolve.calls.context.BasicCallResolutionContext import org.jetbrains.kotlin.resolve.calls.context.CallCandidateResolutionContext import org.jetbrains.kotlin.resolve.calls.context.CheckValueArgumentsMode -import org.jetbrains.kotlin.resolve.calls.inference.ConstraintSystem import org.jetbrains.kotlin.resolve.calls.inference.ConstraintSystemImpl import org.jetbrains.kotlin.resolve.calls.inference.InferenceErrorData import org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.ConstraintPositionKind.* @@ -38,14 +37,11 @@ import org.jetbrains.kotlin.resolve.calls.results.OverloadResolutionResultsImpl import org.jetbrains.kotlin.resolve.calls.results.ResolutionStatus import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo import org.jetbrains.kotlin.resolve.calls.tasks.TracingStrategy +import org.jetbrains.kotlin.types.ErrorUtils import org.jetbrains.kotlin.types.JetType import org.jetbrains.kotlin.types.TypeUtils import org.jetbrains.kotlin.types.expressions.DataFlowUtils -import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils import java.util.ArrayList -import org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.ConstraintPositionKind.* -import org.jetbrains.kotlin.resolve.calls.model.* -import org.jetbrains.kotlin.types.ErrorUtils public class CallCompleter( val argumentTypeResolver: ArgumentTypeResolver, @@ -61,7 +57,7 @@ public class CallCompleter( // for the case 'foo(a)' where 'foo' is a variable, the call 'foo.invoke(a)' shouldn't be completed separately, // it's completed when the outer (variable as function call) is completed - if (!CallResolverUtil.isInvokeCallOnVariable(context.call)) { + if (!isInvokeCallOnVariable(context.call)) { val temporaryTrace = TemporaryBindingTrace.create(context.trace, "Trace to complete a resulting call") 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 c012a961f52..950460736c4 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolver.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolver.java @@ -27,6 +27,7 @@ import org.jetbrains.kotlin.lexer.JetTokens; import org.jetbrains.kotlin.name.Name; import org.jetbrains.kotlin.psi.*; import org.jetbrains.kotlin.resolve.*; +import org.jetbrains.kotlin.resolve.calls.callResolverUtil.CallResolverUtilPackage; import org.jetbrains.kotlin.resolve.calls.callUtil.CallUtilPackage; import org.jetbrains.kotlin.resolve.calls.checkers.CallChecker; import org.jetbrains.kotlin.resolve.calls.context.*; @@ -59,8 +60,8 @@ import java.util.List; import static org.jetbrains.kotlin.diagnostics.Errors.*; import static org.jetbrains.kotlin.resolve.bindingContextUtil.BindingContextUtilPackage.recordScopeAndDataFlowInfo; -import static org.jetbrains.kotlin.resolve.calls.CallResolverUtil.ResolveArgumentsMode.RESOLVE_FUNCTION_ARGUMENTS; -import static org.jetbrains.kotlin.resolve.calls.CallResolverUtil.ResolveArgumentsMode.SHAPE_FUNCTION_ARGUMENTS; +import static org.jetbrains.kotlin.resolve.calls.callResolverUtil.ResolveArgumentsMode.RESOLVE_FUNCTION_ARGUMENTS; +import static org.jetbrains.kotlin.resolve.calls.callResolverUtil.ResolveArgumentsMode.SHAPE_FUNCTION_ARGUMENTS; import static org.jetbrains.kotlin.resolve.calls.results.OverloadResolutionResults.Code.CANDIDATES_WITH_WRONG_RECEIVER; import static org.jetbrains.kotlin.resolve.calls.results.OverloadResolutionResults.Code.INCOMPLETE_TYPE_INFERENCE; import static org.jetbrains.kotlin.types.TypeUtils.NO_EXPECTED_TYPE; @@ -465,7 +466,7 @@ public class CallResolver { @NotNull OverloadResolutionResultsImpl results, @NotNull TracingStrategy tracing ) { - if (CallResolverUtil.isInvokeCallOnVariable(context.call)) return; + if (CallResolverUtilPackage.isInvokeCallOnVariable(context.call)) return; if (!results.isSingleResult()) { if (results.getResultCode() == INCOMPLETE_TYPE_INFERENCE) { argumentTypeResolver.checkTypesWithNoCallee(context, RESOLVE_FUNCTION_ARGUMENTS); @@ -485,7 +486,7 @@ public class CallResolver { @NotNull TracingStrategy tracing ) { Call call = context.call; - if (CallResolverUtil.isInvokeCallOnVariable(call)) return; + if (CallResolverUtilPackage.isInvokeCallOnVariable(call)) return; DelegatingBindingTrace deltasTraceToCacheResolve = new DelegatingBindingTrace( BindingContext.EMPTY, "delta trace for caching resolve of", context.call); 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 d4884e629f9..09075e793f5 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolverUtil.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolverUtil.kt @@ -14,170 +14,134 @@ * limitations under the License. */ -package org.jetbrains.kotlin.resolve.calls; +package org.jetbrains.kotlin.resolve.calls.callResolverUtil -import com.google.common.collect.Lists; -import com.intellij.util.SmartList; -import com.intellij.util.containers.ContainerUtil; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.kotlin.builtins.KotlinBuiltIns; -import org.jetbrains.kotlin.descriptors.*; -import org.jetbrains.kotlin.psi.*; -import org.jetbrains.kotlin.resolve.calls.inference.ConstraintSystem; -import org.jetbrains.kotlin.resolve.scopes.receivers.ExpressionReceiver; -import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue; -import org.jetbrains.kotlin.types.*; +import com.google.common.collect.Lists +import com.intellij.util.containers.ContainerUtil +import org.jetbrains.kotlin.builtins.KotlinBuiltIns +import org.jetbrains.kotlin.descriptors.CallableDescriptor +import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor +import org.jetbrains.kotlin.descriptors.ReceiverParameterDescriptor +import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor +import org.jetbrains.kotlin.psi.Call +import org.jetbrains.kotlin.psi.JetSimpleNameExpression +import org.jetbrains.kotlin.psi.JetSuperExpression +import org.jetbrains.kotlin.psi.ValueArgument +import org.jetbrains.kotlin.resolve.calls.inference.ConstraintSystem +import org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.ConstraintPositionKind.EXPECTED_TYPE_POSITION +import org.jetbrains.kotlin.resolve.scopes.receivers.ExpressionReceiver +import org.jetbrains.kotlin.types.* +import org.jetbrains.kotlin.types.TypeUtils.DONT_CARE -import java.util.Collections; -import java.util.List; - -import static org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.ConstraintPositionKind.EXPECTED_TYPE_POSITION; -import static org.jetbrains.kotlin.types.TypeUtils.DONT_CARE; - -public class CallResolverUtil { - public static enum ResolveArgumentsMode { - RESOLVE_FUNCTION_ARGUMENTS, - SHAPE_FUNCTION_ARGUMENTS - } - - private CallResolverUtil() {} +public enum class ResolveArgumentsMode { + RESOLVE_FUNCTION_ARGUMENTS, + SHAPE_FUNCTION_ARGUMENTS +} - public static boolean hasUnknownFunctionParameter(@NotNull JetType type) { - assert KotlinBuiltIns.isFunctionOrExtensionFunctionType(type); - List arguments = type.getArguments(); - // last argument is return type of function type - List functionParameters = arguments.subList(0, arguments.size() - 1); - for (TypeProjection functionParameter : functionParameters) { - if (TypeUtils.containsSpecialType(functionParameter.getType(), DONT_CARE) - || ErrorUtils.containsUninferredParameter(functionParameter.getType())) { - return true; - } - } - return false; - } - - public static boolean hasUnknownReturnType(@NotNull JetType type) { - assert KotlinBuiltIns.isFunctionOrExtensionFunctionType(type); - JetType returnTypeFromFunctionType = KotlinBuiltIns.getReturnTypeFromFunctionType(type); - return ErrorUtils.containsErrorType(returnTypeFromFunctionType); - } - - public static JetType replaceReturnTypeByUnknown(@NotNull JetType type) { - assert KotlinBuiltIns.isFunctionOrExtensionFunctionType(type); - List arguments = type.getArguments(); - List newArguments = Lists.newArrayList(); - newArguments.addAll(arguments.subList(0, arguments.size() - 1)); - newArguments.add(new TypeProjectionImpl(Variance.INVARIANT, DONT_CARE)); - return new JetTypeImpl(type.getAnnotations(), type.getConstructor(), type.isMarkedNullable(), newArguments, type.getMemberScope()); - } - - private static boolean hasReturnTypeDependentOnUninferredParams( - @NotNull CallableDescriptor candidateDescriptor, - @NotNull ConstraintSystem constraintSystem - ) { - JetType returnType = candidateDescriptor.getReturnType(); - if (returnType == null) return false; - - for (TypeParameterDescriptor typeVariable : constraintSystem.getTypeVariables()) { - JetType inferredValueForTypeVariable = constraintSystem.getTypeBounds(typeVariable).getValue(); - if (inferredValueForTypeVariable == null) { - if (TypeUtils.dependsOnTypeParameters(returnType, Collections.singleton(typeVariable))) { - return true; - } - } - } - return false; - } - - public static boolean hasInferredReturnType( - @NotNull CallableDescriptor candidateDescriptor, - @NotNull ConstraintSystem constraintSystem - ) { - if (hasReturnTypeDependentOnUninferredParams(candidateDescriptor, constraintSystem)) return false; - - // Expected type mismatch was reported before as 'TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH' - if (constraintSystem.getStatus().hasOnlyErrorsFromPosition(EXPECTED_TYPE_POSITION.position())) return false; - return true; - } - - @NotNull - public static JetType getErasedReceiverType( - @NotNull ReceiverParameterDescriptor receiverParameterDescriptor, - @NotNull CallableDescriptor descriptor - ) { - JetType receiverType = receiverParameterDescriptor.getType(); - for (TypeParameterDescriptor typeParameter : descriptor.getTypeParameters()) { - if (typeParameter.getTypeConstructor().equals(receiverType.getConstructor())) { - receiverType = typeParameter.getUpperBoundsAsType(); - } - } - List fakeTypeArguments = ContainerUtil.newSmartList(); - for (TypeProjection typeProjection : receiverType.getArguments()) { - fakeTypeArguments.add(new TypeProjectionImpl(typeProjection.getProjectionKind(), DONT_CARE)); - } - return new JetTypeImpl( - receiverType.getAnnotations(), receiverType.getConstructor(), receiverType.isMarkedNullable(), - fakeTypeArguments, ErrorUtils.createErrorScope("Error scope for erased receiver type", /*throwExceptions=*/true)); - } - - public static boolean isOrOverridesSynthesized(@NotNull CallableMemberDescriptor descriptor) { - if (descriptor.getKind() == CallableMemberDescriptor.Kind.SYNTHESIZED) { - return true; - } - if (descriptor.getKind() == CallableMemberDescriptor.Kind.FAKE_OVERRIDE) { - for (CallableMemberDescriptor overridden : descriptor.getOverriddenDescriptors()) { - if (!isOrOverridesSynthesized(overridden)) { - return false; - } - } - return true; - } - return false; - } - - public static boolean isInvokeCallOnVariable(@NotNull Call call) { - if (call.getCallType() != Call.CallType.INVOKE) return false; - ReceiverValue dispatchReceiver = call.getDispatchReceiver(); - //calleeExpressionAsDispatchReceiver for invoke is always ExpressionReceiver, see CallForImplicitInvoke - JetExpression expression = ((ExpressionReceiver) dispatchReceiver).getExpression(); - return expression instanceof JetSimpleNameExpression; - } - - public static boolean isInvokeCallOnExpressionWithBothReceivers(@NotNull Call call) { - if (call.getCallType() != Call.CallType.INVOKE || isInvokeCallOnVariable(call)) return false; - return call.getExplicitReceiver().exists() && call.getDispatchReceiver().exists(); - } - - public static JetSuperExpression getSuperCallExpression(@NotNull Call call) { - ReceiverValue explicitReceiver = call.getExplicitReceiver(); - if (explicitReceiver instanceof ExpressionReceiver) { - JetExpression receiverExpression = ((ExpressionReceiver) explicitReceiver).getExpression(); - if (receiverExpression instanceof JetSuperExpression) { - return (JetSuperExpression) receiverExpression; - } - } - return null; - } - - @NotNull - public static JetType getEffectiveExpectedType(@NotNull ValueParameterDescriptor parameterDescriptor, @NotNull ValueArgument argument) { - if (argument.getSpreadElement() != null) { - if (parameterDescriptor.getVarargElementType() == null) { - // Spread argument passed to a non-vararg parameter, an error is already reported by ValueArgumentsToParametersMapper - return DONT_CARE; - } - else { - return parameterDescriptor.getType(); - } - } - else { - JetType varargElementType = parameterDescriptor.getVarargElementType(); - if (varargElementType != null) { - return varargElementType; - } - - return parameterDescriptor.getType(); - } +public fun hasUnknownFunctionParameter(type: JetType): Boolean { + assert(KotlinBuiltIns.isFunctionOrExtensionFunctionType(type)) + val arguments = type.getArguments() + // last argument is return type of function type + val functionParameters = arguments.subList(0, arguments.size() - 1) + return functionParameters.any { + TypeUtils.containsSpecialType(it.getType(), DONT_CARE) || ErrorUtils.containsUninferredParameter(it.getType()) } } + +public fun hasUnknownReturnType(type: JetType): Boolean { + assert(KotlinBuiltIns.isFunctionOrExtensionFunctionType(type)) + val returnTypeFromFunctionType = KotlinBuiltIns.getReturnTypeFromFunctionType(type) + return ErrorUtils.containsErrorType(returnTypeFromFunctionType) +} + +public fun replaceReturnTypeByUnknown(type: JetType): JetType { + assert(KotlinBuiltIns.isFunctionOrExtensionFunctionType(type)) + val arguments = type.getArguments() + val newArguments = Lists.newArrayList() + newArguments.addAll(arguments.subList(0, arguments.size() - 1)) + newArguments.add(TypeProjectionImpl(Variance.INVARIANT, DONT_CARE)) + return JetTypeImpl(type.getAnnotations(), type.getConstructor(), type.isMarkedNullable(), newArguments, type.getMemberScope()) +} + +private fun hasReturnTypeDependentOnUninferredParams(candidateDescriptor: CallableDescriptor, constraintSystem: ConstraintSystem): Boolean { + val returnType = candidateDescriptor.getReturnType() ?: return false + + for (typeVariable in constraintSystem.getTypeVariables()) { + val inferredValueForTypeVariable = constraintSystem.getTypeBounds(typeVariable).value + if (inferredValueForTypeVariable == null) { + if (TypeUtils.dependsOnTypeParameters(returnType, setOf(typeVariable))) { + return true + } + } + } + return false +} + +public fun hasInferredReturnType(candidateDescriptor: CallableDescriptor, constraintSystem: ConstraintSystem): Boolean { + if (hasReturnTypeDependentOnUninferredParams(candidateDescriptor, constraintSystem)) return false + + // Expected type mismatch was reported before as 'TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH' + if (constraintSystem.getStatus().hasOnlyErrorsFromPosition(EXPECTED_TYPE_POSITION.position())) return false + return true +} + +public fun getErasedReceiverType(receiverParameterDescriptor: ReceiverParameterDescriptor, descriptor: CallableDescriptor): JetType { + var receiverType = receiverParameterDescriptor.getType() + for (typeParameter in descriptor.getTypeParameters()) { + if (typeParameter.getTypeConstructor() == receiverType.getConstructor()) { + receiverType = typeParameter.getUpperBoundsAsType() + } + } + val fakeTypeArguments = ContainerUtil.newSmartList() + for (typeProjection in receiverType.getArguments()) { + fakeTypeArguments.add(TypeProjectionImpl(typeProjection.getProjectionKind(), DONT_CARE)) + } + return JetTypeImpl(receiverType.getAnnotations(), receiverType.getConstructor(), receiverType.isMarkedNullable(), fakeTypeArguments, + ErrorUtils.createErrorScope("Error scope for erased receiver type", /*throwExceptions=*/true)) +} + +public fun isOrOverridesSynthesized(descriptor: CallableMemberDescriptor): Boolean { + if (descriptor.getKind() == CallableMemberDescriptor.Kind.SYNTHESIZED) { + return true + } + if (descriptor.getKind() == CallableMemberDescriptor.Kind.FAKE_OVERRIDE) { + return descriptor.getOverriddenDescriptors().all { + isOrOverridesSynthesized(it) + } + } + return false +} + +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() + return expression is JetSimpleNameExpression +} + +public fun isInvokeCallOnExpressionWithBothReceivers(call: Call): Boolean { + if (call.getCallType() !== Call.CallType.INVOKE || isInvokeCallOnVariable(call)) return false + return call.getExplicitReceiver().exists() && call.getDispatchReceiver().exists() +} + +public fun getSuperCallExpression(call: Call): JetSuperExpression? { + return (call.getExplicitReceiver() as? ExpressionReceiver)?.getExpression() as? JetSuperExpression +} + +public fun getEffectiveExpectedType(parameterDescriptor: ValueParameterDescriptor, argument: ValueArgument): JetType { + if (argument.getSpreadElement() != null) { + if (parameterDescriptor.getVarargElementType() == null) { + // Spread argument passed to a non-vararg parameter, an error is already reported by ValueArgumentsToParametersMapper + return DONT_CARE + } + return parameterDescriptor.getType() + } + val varargElementType = parameterDescriptor.getVarargElementType() + if (varargElementType != null) { + return varargElementType + } + + return parameterDescriptor.getType() +} diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CandidateResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CandidateResolver.java index 8491a71e8f5..15ea32feb42 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CandidateResolver.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CandidateResolver.java @@ -18,7 +18,6 @@ package org.jetbrains.kotlin.resolve.calls; import com.google.common.collect.Lists; import com.google.common.collect.Sets; -import kotlin.jvm.functions.Function1; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.kotlin.builtins.KotlinBuiltIns; @@ -26,6 +25,8 @@ import org.jetbrains.kotlin.progress.ProgressIndicatorAndCompilationCanceledStat import org.jetbrains.kotlin.descriptors.*; import org.jetbrains.kotlin.psi.*; import org.jetbrains.kotlin.resolve.*; +import org.jetbrains.kotlin.resolve.calls.callResolverUtil.CallResolverUtilPackage; +import org.jetbrains.kotlin.resolve.calls.callResolverUtil.ResolveArgumentsMode; import org.jetbrains.kotlin.resolve.calls.callUtil.CallUtilPackage; import org.jetbrains.kotlin.resolve.calls.context.CallCandidateResolutionContext; import org.jetbrains.kotlin.resolve.calls.context.CallResolutionContext; @@ -55,9 +56,9 @@ import java.util.Map; import static org.jetbrains.kotlin.diagnostics.Errors.PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT; import static org.jetbrains.kotlin.diagnostics.Errors.SUPER_CANT_BE_EXTENSION_RECEIVER; -import static org.jetbrains.kotlin.resolve.calls.CallResolverUtil.ResolveArgumentsMode.SHAPE_FUNCTION_ARGUMENTS; -import static org.jetbrains.kotlin.resolve.calls.CallResolverUtil.getEffectiveExpectedType; import static org.jetbrains.kotlin.resolve.calls.CallTransformer.CallForImplicitInvoke; +import static org.jetbrains.kotlin.resolve.calls.callResolverUtil.CallResolverUtilPackage.getEffectiveExpectedType; +import static org.jetbrains.kotlin.resolve.calls.callResolverUtil.ResolveArgumentsMode.SHAPE_FUNCTION_ARGUMENTS; import static org.jetbrains.kotlin.resolve.calls.results.ResolutionStatus.*; import static org.jetbrains.kotlin.types.TypeUtils.noExpectedType; @@ -295,7 +296,7 @@ public class CandidateResolver { @NotNull private ValueArgumentsCheckingResult checkAllValueArguments( @NotNull CallCandidateResolutionContext context, - @NotNull CallResolverUtil.ResolveArgumentsMode resolveFunctionArgumentBodies) { + @NotNull ResolveArgumentsMode resolveFunctionArgumentBodies) { return checkAllValueArguments(context, context.candidateCall.getTrace(), resolveFunctionArgumentBodies); } @@ -303,7 +304,7 @@ public class CandidateResolver { public ValueArgumentsCheckingResult checkAllValueArguments( @NotNull CallCandidateResolutionContext context, @NotNull BindingTrace trace, - @NotNull CallResolverUtil.ResolveArgumentsMode resolveFunctionArgumentBodies + @NotNull ResolveArgumentsMode resolveFunctionArgumentBodies ) { ValueArgumentsCheckingResult checkingResult = checkValueArgumentTypes( context, context.candidateCall, trace, resolveFunctionArgumentBodies); @@ -346,7 +347,7 @@ public class CandidateResolver { @NotNull CallResolutionContext context, @NotNull MutableResolvedCall candidateCall, @NotNull BindingTrace trace, - @NotNull CallResolverUtil.ResolveArgumentsMode resolveFunctionArgumentBodies) { + @NotNull ResolveArgumentsMode resolveFunctionArgumentBodies) { ResolutionStatus resultStatus = SUCCESS; List argumentTypes = Lists.newArrayList(); MutableDataFlowInfoForArguments infoForArguments = candidateCall.getDataFlowInfoForArguments(); @@ -423,7 +424,7 @@ public class CandidateResolver { ResolutionStatus status = SUCCESS; // For the expressions like '42.(f)()' where f: String.() -> Unit we'd like to generate a type mismatch error on '1', // not to throw away the candidate, so the following check is skipped. - if (!CallResolverUtil.isInvokeCallOnExpressionWithBothReceivers(context.call)) { + if (!CallResolverUtilPackage.isInvokeCallOnExpressionWithBothReceivers(context.call)) { status = status.combine(checkReceiverTypeError(context, extensionReceiver, candidateCall.getExtensionReceiver())); } status = status.combine(checkReceiverTypeError(context, dispatchReceiver, candidateCall.getDispatchReceiver())); @@ -439,7 +440,7 @@ public class CandidateResolver { D candidateDescriptor = context.candidateCall.getCandidateDescriptor(); - JetType erasedReceiverType = CallResolverUtil.getErasedReceiverType(receiverParameterDescriptor, candidateDescriptor); + JetType erasedReceiverType = CallResolverUtilPackage.getErasedReceiverType(receiverParameterDescriptor, candidateDescriptor); boolean isSubtypeBySmartCast = SmartCastUtils.isSubTypeBySmartCastIgnoringNullability(receiverArgument, erasedReceiverType, context); if (!isSubtypeBySmartCast) { 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 cbde47b02c5..624c889111c 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/GenericCandidateResolver.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/GenericCandidateResolver.kt @@ -16,19 +16,17 @@ package org.jetbrains.kotlin.resolve.calls -import com.google.common.collect.Maps import org.jetbrains.kotlin.builtins.KotlinBuiltIns import org.jetbrains.kotlin.descriptors.CallableDescriptor -import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor import org.jetbrains.kotlin.psi.JetExpression import org.jetbrains.kotlin.psi.JetPsiUtil import org.jetbrains.kotlin.psi.ValueArgument import org.jetbrains.kotlin.resolve.FunctionDescriptorUtil import org.jetbrains.kotlin.resolve.calls.ArgumentTypeResolver.getLastElementDeparenthesized -import org.jetbrains.kotlin.resolve.calls.CallResolverUtil.ResolveArgumentsMode.RESOLVE_FUNCTION_ARGUMENTS -import org.jetbrains.kotlin.resolve.calls.CallResolverUtil.ResolveArgumentsMode.SHAPE_FUNCTION_ARGUMENTS -import org.jetbrains.kotlin.resolve.calls.CallResolverUtil.getEffectiveExpectedType +import org.jetbrains.kotlin.resolve.calls.callResolverUtil.* +import org.jetbrains.kotlin.resolve.calls.callResolverUtil.ResolveArgumentsMode.RESOLVE_FUNCTION_ARGUMENTS +import org.jetbrains.kotlin.resolve.calls.callResolverUtil.ResolveArgumentsMode.SHAPE_FUNCTION_ARGUMENTS import org.jetbrains.kotlin.resolve.calls.callUtil.getCall import org.jetbrains.kotlin.resolve.calls.context.CallCandidateResolutionContext import org.jetbrains.kotlin.resolve.calls.context.ContextDependency.INDEPENDENT @@ -130,7 +128,7 @@ class GenericCandidateResolver( substitutor: TypeSubstitutor, constraintSystem: ConstraintSystem, context: CallCandidateResolutionContext<*>, - resolveFunctionArgumentBodies: CallResolverUtil.ResolveArgumentsMode + resolveFunctionArgumentBodies: ResolveArgumentsMode ) { val effectiveExpectedType = getEffectiveExpectedType(valueParameterDescriptor, valueArgument) @@ -239,14 +237,14 @@ class GenericCandidateResolver( expectedType = argumentTypeResolver.getShapeTypeOfFunctionLiteral(functionLiteral, context.scope, context.trace, false) } if (expectedType == null || !KotlinBuiltIns.isFunctionOrExtensionFunctionType(expectedType) - || CallResolverUtil.hasUnknownFunctionParameter(expectedType)) { + || hasUnknownFunctionParameter(expectedType)) { return } val dataFlowInfoForArguments = context.candidateCall.getDataFlowInfoForArguments() val dataFlowInfoForArgument = dataFlowInfoForArguments.getInfo(valueArgument) //todo analyze function literal body once in 'dependent' mode, then complete it with respect to expected type - val hasExpectedReturnType = !CallResolverUtil.hasUnknownReturnType(expectedType) + val hasExpectedReturnType = !hasUnknownReturnType(expectedType) val position = VALUE_PARAMETER_POSITION.position(valueParameterDescriptor.getIndex()) if (hasExpectedReturnType) { val temporaryToResolveFunctionLiteral = TemporaryTraceAndCache.create( @@ -267,7 +265,7 @@ class GenericCandidateResolver( return } } - val expectedTypeWithoutReturnType = if (hasExpectedReturnType) CallResolverUtil.replaceReturnTypeByUnknown(expectedType) else expectedType + val expectedTypeWithoutReturnType = if (hasExpectedReturnType) replaceReturnTypeByUnknown(expectedType) else expectedType val newContext = context.replaceExpectedType(expectedTypeWithoutReturnType).replaceDataFlowInfo(dataFlowInfoForArgument) .replaceContextDependency(INDEPENDENT) val type = argumentTypeResolver.getFunctionLiteralTypeInfo(argumentExpression, functionLiteral, newContext, RESOLVE_FUNCTION_ARGUMENTS).type diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/model/ResolvedCallImpl.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/model/ResolvedCallImpl.java index c2ecc238381..5b6ac901d68 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/model/ResolvedCallImpl.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/model/ResolvedCallImpl.java @@ -26,7 +26,7 @@ import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor; import org.jetbrains.kotlin.psi.Call; import org.jetbrains.kotlin.psi.ValueArgument; import org.jetbrains.kotlin.resolve.DelegatingBindingTrace; -import org.jetbrains.kotlin.resolve.calls.CallResolverUtil; +import org.jetbrains.kotlin.resolve.calls.callResolverUtil.CallResolverUtilPackage; import org.jetbrains.kotlin.resolve.calls.callUtil.CallUtilPackage; import org.jetbrains.kotlin.resolve.calls.inference.ConstraintSystem; import org.jetbrains.kotlin.resolve.calls.results.ResolutionStatus; @@ -300,7 +300,8 @@ public class ResolvedCallImpl implements MutableRe @Override public boolean hasInferredReturnType() { if (!completed) { - hasInferredReturnType = constraintSystem == null || CallResolverUtil.hasInferredReturnType(candidateDescriptor, constraintSystem); + hasInferredReturnType = constraintSystem == null || + CallResolverUtilPackage.hasInferredReturnType(candidateDescriptor, constraintSystem); } assert hasInferredReturnType != null : "The property 'hasInferredReturnType' was not set when the call was completed."; return hasInferredReturnType; diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/TaskPrioritizer.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/TaskPrioritizer.kt index dadc7605f71..1c7ae65a94e 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/TaskPrioritizer.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/TaskPrioritizer.kt @@ -23,7 +23,7 @@ import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.psi.Call import org.jetbrains.kotlin.resolve.DescriptorUtils -import org.jetbrains.kotlin.resolve.calls.CallResolverUtil.isOrOverridesSynthesized +import org.jetbrains.kotlin.resolve.calls.callResolverUtil.isOrOverridesSynthesized import org.jetbrains.kotlin.resolve.calls.context.BasicCallResolutionContext import org.jetbrains.kotlin.resolve.calls.smartcasts.SmartCastUtils import org.jetbrains.kotlin.resolve.calls.tasks.ExplicitReceiverKind.BOTH_RECEIVERS diff --git a/idea/src/org/jetbrains/kotlin/idea/codeInsight/OverrideMethodsHandler.java b/idea/src/org/jetbrains/kotlin/idea/codeInsight/OverrideMethodsHandler.java index c18e016f439..38aa59bb999 100644 --- a/idea/src/org/jetbrains/kotlin/idea/codeInsight/OverrideMethodsHandler.java +++ b/idea/src/org/jetbrains/kotlin/idea/codeInsight/OverrideMethodsHandler.java @@ -25,7 +25,7 @@ import org.jetbrains.kotlin.descriptors.DeclarationDescriptor; import org.jetbrains.kotlin.idea.core.codeInsight.OverrideImplementMethodsHandler; import org.jetbrains.kotlin.resolve.OverrideResolver; import org.jetbrains.kotlin.resolve.OverridingUtil; -import org.jetbrains.kotlin.resolve.calls.CallResolverUtil; +import org.jetbrains.kotlin.resolve.calls.callResolverUtil.CallResolverUtilPackage; import org.jetbrains.kotlin.types.JetType; import java.util.HashSet; @@ -49,7 +49,7 @@ public class OverrideMethodsHandler extends OverrideImplementMethodsHandler { Set result = new HashSet(); for (CallableMemberDescriptor superMethod : superMethods) { if (superMethod.getModality().isOverridable()) { - if (!CallResolverUtil.isOrOverridesSynthesized(superMethod)) { + if (!CallResolverUtilPackage.isOrOverridesSynthesized(superMethod)) { result.add(superMethod); } } 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 488903971a1..ffb71b7b279 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 @@ -25,7 +25,7 @@ import org.jetbrains.kotlin.js.translate.general.Translation import org.jetbrains.kotlin.js.translate.reference.CallArgumentTranslator import org.jetbrains.kotlin.js.translate.utils.AnnotationsUtils import org.jetbrains.kotlin.psi.Call.CallType -import org.jetbrains.kotlin.resolve.calls.CallResolverUtil +import org.jetbrains.kotlin.resolve.calls.callResolverUtil.isInvokeCallOnVariable import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall import org.jetbrains.kotlin.resolve.calls.model.VariableAsFunctionResolvedCall import org.jetbrains.kotlin.resolve.calls.tasks.ExplicitReceiverKind @@ -102,7 +102,7 @@ private fun translateCall(context: TranslationContext, } val call = resolvedCall.getCall() - if (call.getCallType() == CallType.INVOKE && !CallResolverUtil.isInvokeCallOnVariable(call)) { + if (call.getCallType() == CallType.INVOKE && !isInvokeCallOnVariable(call)) { val explicitReceiversForInvoke = computeExplicitReceiversForInvoke(context, resolvedCall, explicitReceivers) return translateFunctionCall(context, resolvedCall, explicitReceiversForInvoke) }