From 937d1913b87b6f8e546621a093d71b3c17fe0b45 Mon Sep 17 00:00:00 2001 From: Yan Zhulanow Date: Mon, 5 Oct 2015 15:42:39 +0300 Subject: [PATCH] Automatically put 'operator' modifier on appropriate Java methods --- .../AccessorForConstructorDescriptor.kt | 4 +- .../AccessorForFunctionDescriptor.java | 6 +- .../kotlin/codegen/ClosureCodegen.java | 6 +- .../kotlin/codegen/MemberCodegen.java | 2 +- .../codegen/PropertyReferenceCodegen.kt | 2 +- .../kotlin/codegen/SamWrapperCodegen.java | 6 +- .../codegen/inline/InlineCodegenUtil.java | 3 +- .../kotlin/codegen/state/JetTypeMapper.java | 6 +- .../java/sam/SingleAbstractMethodUtils.java | 8 +- .../checkers/ReflectionAPICallChecker.kt | 3 +- .../SignaturesPropagationData.java | 4 +- .../synthetic/SamAdapterFunctionsScope.kt | 2 +- .../rendering/DefaultErrorMessages.java | 3 +- .../kotlin/resolve/DescriptorResolver.java | 9 +- .../resolve/FunctionDescriptorResolver.kt | 6 +- .../resolve/FunctionDescriptorUtil.java | 10 +-- .../kotlin/resolve/OperatorModifierChecker.kt | 21 +---- .../kotlin/resolve/calls/CallResolver.java | 4 +- .../kotlin/resolve/calls/CallTransformer.java | 5 +- .../resolve/calls/checkers/InlineChecker.java | 4 +- .../tasks/CallableDescriptorCollectors.kt | 6 +- .../resolve/calls/tasks/dynamicCalls.kt | 4 +- .../resolve/calls/tasks/synthesizedInvokes.kt | 10 +-- .../evaluate/ConstantExpressionEvaluator.kt | 9 +- .../BasicExpressionTypingVisitor.java | 11 +-- .../ControlStructureTypingUtils.java | 4 +- .../expressions/OperatorConventions.java | 52 +++++------ .../delegatedProperties.txt | 4 +- .../nullabilityWarnings/invoke.kt | 6 +- .../nullabilityWarnings/invoke.txt | 2 +- .../nullabilityWarnings/multiDeclaration.kt | 4 +- .../nullabilityWarnings/multiDeclaration.txt | 4 +- .../nullabilityWarnings/passToJava.txt | 2 +- .../compiledJava/InnerClassesInGeneric.txt | 2 +- .../loadJava/compiledJava/InnerOfGeneric.txt | 2 +- .../ReturnInnerSubclassOfSupersInner.txt | 2 +- .../ReturnInnerSubclassOfSupersInner.txt | 2 +- .../JavaConstructorDescriptor.java | 4 +- .../descriptors/JavaMethodDescriptor.java | 21 ++++- .../java/lazy/descriptors/LazyJavaScope.kt | 4 +- .../functions/FunctionInvokeDescriptor.kt | 5 +- .../impl/ConstructorDescriptorImpl.java | 2 +- .../impl/FunctionDescriptorImpl.java | 24 +++--- .../impl/ScriptCodeDescriptor.java | 2 +- .../impl/SimpleFunctionDescriptorImpl.java | 6 +- .../kotlin/resolve/DescriptorFactory.java | 4 +- .../jetbrains/kotlin/types/ErrorUtils.java | 4 +- .../kotlin/util/OperatorNameConventions.kt | 86 +++++++++++++++++++ .../deserialization/MemberDeserializer.kt | 6 +- .../intentions/OperatorToFunctionIntention.kt | 8 +- .../idea/search/usagesSearch/conventions.kt | 13 +-- .../stepping/KotlinLambdaMethodFilter.kt | 4 +- .../KotlinLambdaSmartStepIntoTarget.kt | 4 +- .../KotlinRecursiveCallLineMarkerProvider.kt | 3 +- .../inspections/OperatorModifierInspection.kt | 17 ++-- .../inspections/UnusedSymbolInspection.kt | 3 +- .../ReplaceContainsIntention.kt | 4 +- .../ReplaceInvokeIntention.kt | 4 +- .../callableBuilder/CallableBuilder.kt | 2 +- .../CreateHasNextFunctionActionFactory.kt | 4 +- .../CreateInvokeFunctionActionFactory.kt | 4 +- .../CreateIteratorFunctionActionFactory.kt | 4 +- .../CreateNextFunctionActionFactory.kt | 4 +- .../callTranslator/FunctionCallCases.kt | 4 +- .../PrimitiveBinaryOperationFIF.java | 3 +- .../kotlin/js/translate/utils/JsAstUtils.java | 3 +- .../js/translate/utils/JsDescriptorUtils.java | 4 +- 67 files changed, 285 insertions(+), 215 deletions(-) create mode 100644 core/descriptors/src/org/jetbrains/kotlin/util/OperatorNameConventions.kt diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/AccessorForConstructorDescriptor.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/AccessorForConstructorDescriptor.kt index 697cd13b2a1..585f0b0d543 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/AccessorForConstructorDescriptor.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/AccessorForConstructorDescriptor.kt @@ -47,9 +47,7 @@ public class AccessorForConstructorDescriptor( copyValueParameters(calleeDescriptor), calleeDescriptor.returnType, Modality.FINAL, - Visibilities.LOCAL, - false, - false + Visibilities.LOCAL ) } } diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/AccessorForFunctionDescriptor.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/AccessorForFunctionDescriptor.java index 9e3e6e346a4..3b333bf500d 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/AccessorForFunctionDescriptor.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/AccessorForFunctionDescriptor.java @@ -47,9 +47,9 @@ public class AccessorForFunctionDescriptor extends AbstractAccessorForFunctionDe copyValueParameters(descriptor), descriptor.getReturnType(), Modality.FINAL, - Visibilities.LOCAL, - descriptor.isOperator(), - descriptor.isInfix()); + Visibilities.LOCAL); + setOperator(descriptor.isOperator()); + setInfix(descriptor.isInfix()); } @NotNull diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/ClosureCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/ClosureCodegen.java index 6c7db88b9c0..bb23a1eb483 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/ClosureCodegen.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/ClosureCodegen.java @@ -43,7 +43,7 @@ import org.jetbrains.kotlin.resolve.scopes.JetScope; import org.jetbrains.kotlin.serialization.DescriptorSerializer; import org.jetbrains.kotlin.serialization.ProtoBuf; import org.jetbrains.kotlin.types.JetType; -import org.jetbrains.kotlin.types.expressions.OperatorConventions; +import org.jetbrains.kotlin.util.OperatorNameConventions; import org.jetbrains.kotlin.utils.UtilsPackage; import org.jetbrains.org.objectweb.asm.AnnotationVisitor; import org.jetbrains.org.objectweb.asm.MethodVisitor; @@ -194,7 +194,7 @@ public class ClosureCodegen extends MemberCodegen { descriptorForBridges .initialize(null, erasedInterfaceFunction.getDispatchReceiverParameter(), erasedInterfaceFunction.getTypeParameters(), erasedInterfaceFunction.getValueParameters(), erasedInterfaceFunction.getReturnType(), - Modality.OPEN, erasedInterfaceFunction.getVisibility(), false, false); + Modality.OPEN, erasedInterfaceFunction.getVisibility()); descriptorForBridges.addOverriddenDescriptor(erasedInterfaceFunction); functionCodegen.generateBridges(descriptorForBridges); @@ -465,6 +465,6 @@ public class ClosureCodegen extends MemberCodegen { ? getBuiltIns(elementDescriptor).getFunction(arity) : getBuiltIns(elementDescriptor).getExtensionFunction(arity); JetScope scope = elementClass.getDefaultType().getMemberScope(); - return scope.getFunctions(OperatorConventions.INVOKE, NoLookupLocation.FROM_BACKEND).iterator().next(); + return scope.getFunctions(OperatorNameConventions.INVOKE, NoLookupLocation.FROM_BACKEND).iterator().next(); } } diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/MemberCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/MemberCodegen.java index dcd727ec58a..7ec8c9ea26b 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/MemberCodegen.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/MemberCodegen.java @@ -332,7 +332,7 @@ public abstract class MemberCodegenemptyList(), Collections.emptyList(), DescriptorUtilPackage.getModule(descriptor).getBuiltIns().getUnitType(), - null, Visibilities.PRIVATE, false, false); + null, Visibilities.PRIVATE); this.clInit = new ExpressionCodegen(mv, new FrameMap(), Type.VOID_TYPE, context.intoFunction(clInit), state, this); } diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/PropertyReferenceCodegen.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/PropertyReferenceCodegen.kt index 3d9eec41a4f..d7b2cb09ee3 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/PropertyReferenceCodegen.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/PropertyReferenceCodegen.kt @@ -150,7 +150,7 @@ public class PropertyReferenceCodegen( SourceElement.NO_SOURCE ) fakeDescriptor.initialize(null, classDescriptor.getThisAsReceiverParameter(), emptyList(), emptyList(), - classDescriptor.builtIns.getAnyType(), Modality.OPEN, Visibilities.PUBLIC, false, false) + classDescriptor.builtIns.getAnyType(), Modality.OPEN, Visibilities.PUBLIC) val fakeCodegen = ExpressionCodegen( this, FrameMap(), OBJECT_TYPE, context.intoFunction(fakeDescriptor), state, this@PropertyReferenceCodegen diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/SamWrapperCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/SamWrapperCodegen.java index 915517e8d89..22c128d27e8 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/SamWrapperCodegen.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/SamWrapperCodegen.java @@ -31,7 +31,7 @@ import org.jetbrains.kotlin.name.Name; import org.jetbrains.kotlin.psi.JetFile; import org.jetbrains.kotlin.resolve.DescriptorUtils; import org.jetbrains.kotlin.types.JetType; -import org.jetbrains.kotlin.types.expressions.OperatorConventions; +import org.jetbrains.kotlin.util.OperatorNameConventions; import org.jetbrains.org.objectweb.asm.MethodVisitor; import org.jetbrains.org.objectweb.asm.Type; import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter; @@ -147,7 +147,7 @@ public class SamWrapperCodegen { (ClassDescriptor) erasedInterfaceFunction.getContainingDeclaration(), OwnerKind.IMPLEMENTATION, state), cv, state, parentCodegen); FunctionDescriptor invokeFunction = - functionJetType.getMemberScope().getFunctions(OperatorConventions.INVOKE, NoLookupLocation.FROM_BACKEND).iterator().next().getOriginal(); + functionJetType.getMemberScope().getFunctions(OperatorNameConventions.INVOKE, NoLookupLocation.FROM_BACKEND).iterator().next().getOriginal(); StackValue functionField = StackValue.field(functionType, ownerType, FUNCTION_FIELD_NAME, false, StackValue.none()); codegen.genDelegate(erasedInterfaceFunction, invokeFunction, functionField); @@ -161,7 +161,7 @@ public class SamWrapperCodegen { descriptorForBridges .initialize(null, originalInterfaceErased.getDispatchReceiverParameter(), originalInterfaceErased.getTypeParameters(), originalInterfaceErased.getValueParameters(), originalInterfaceErased.getReturnType(), - Modality.OPEN, originalInterfaceErased.getVisibility(), false, false); + Modality.OPEN, originalInterfaceErased.getVisibility()); descriptorForBridges.addOverriddenDescriptor(originalInterfaceErased); codegen.generateBridges(descriptorForBridges); diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegenUtil.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegenUtil.java index 6d7da48b2ec..18c9f23c45f 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegenUtil.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegenUtil.java @@ -46,6 +46,7 @@ import org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilPackage; import org.jetbrains.kotlin.resolve.jvm.AsmTypes; import org.jetbrains.kotlin.resolve.jvm.JvmClassName; import org.jetbrains.kotlin.types.expressions.OperatorConventions; +import org.jetbrains.kotlin.util.OperatorNameConventions; import org.jetbrains.org.objectweb.asm.*; import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter; import org.jetbrains.org.objectweb.asm.tree.*; @@ -235,7 +236,7 @@ public class InlineCodegenUtil { } public static boolean isInvokeOnLambda(@NotNull String owner, @NotNull String name) { - return OperatorConventions.INVOKE.asString().equals(name) && + return OperatorNameConventions.INVOKE.asString().equals(name) && owner.startsWith(NUMBERED_FUNCTION_PREFIX) && isInteger(owner.substring(NUMBERED_FUNCTION_PREFIX.length())); } diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/JetTypeMapper.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/JetTypeMapper.java index b1f8a62c6e3..6e46a0ec99a 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/JetTypeMapper.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/JetTypeMapper.java @@ -64,7 +64,7 @@ import org.jetbrains.kotlin.resolve.scopes.JetScope; import org.jetbrains.kotlin.serialization.deserialization.DeserializedType; import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedCallableMemberDescriptor; import org.jetbrains.kotlin.types.*; -import org.jetbrains.kotlin.types.expressions.OperatorConventions; +import org.jetbrains.kotlin.util.OperatorNameConventions; import org.jetbrains.org.objectweb.asm.Type; import org.jetbrains.org.objectweb.asm.commons.Method; @@ -845,10 +845,10 @@ public class JetTypeMapper { } } - return OperatorConventions.INVOKE.asString(); + return OperatorNameConventions.INVOKE.asString(); } else if (isLocalFunction(descriptor) || isFunctionExpression(descriptor)) { - return OperatorConventions.INVOKE.asString(); + return OperatorNameConventions.INVOKE.asString(); } else { return updateMemberNameIfInternal(descriptor.getName().asString(), descriptor); diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/sam/SingleAbstractMethodUtils.java b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/sam/SingleAbstractMethodUtils.java index 82a6dd28dd3..09f39989947 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/sam/SingleAbstractMethodUtils.java +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/sam/SingleAbstractMethodUtils.java @@ -170,9 +170,7 @@ public class SingleAbstractMethodUtils { Arrays.asList(parameter), returnType, Modality.FINAL, - samInterface.getVisibility(), - false, - false + samInterface.getVisibility() ); return result; @@ -208,9 +206,7 @@ public class SingleAbstractMethodUtils { valueParameters, returnType, Modality.FINAL, - original.getVisibility(), - false, - false + original.getVisibility() ); } }); diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/calls/checkers/ReflectionAPICallChecker.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/calls/checkers/ReflectionAPICallChecker.kt index 1533720f320..9c765fac59f 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/calls/checkers/ReflectionAPICallChecker.kt +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/calls/checkers/ReflectionAPICallChecker.kt @@ -30,6 +30,7 @@ import org.jetbrains.kotlin.serialization.deserialization.findClassAcrossModuleD import org.jetbrains.kotlin.storage.StorageManager import org.jetbrains.kotlin.types.expressions.OperatorConventions import org.jetbrains.kotlin.storage.get +import org.jetbrains.kotlin.util.OperatorNameConventions /** * If there's no Kotlin reflection implementation found in the classpath, checks that there are no usages @@ -58,7 +59,7 @@ class ReflectionAPICallChecker(private val module: ModuleDescriptor, storageMana // - 'get'/'set' on properties val name = descriptor.getName() when { - name == OperatorConventions.INVOKE -> return + name == OperatorNameConventions.INVOKE -> return name.asString() == "name" -> return (name.asString() == "get" || name.asString() == "set") && kPropertyClasses.any { kProperty -> DescriptorUtils.isSubclass(containingClass, kProperty) } -> return diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/kotlinSignature/SignaturesPropagationData.java b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/kotlinSignature/SignaturesPropagationData.java index 1e2fac29c35..21d53a7d6eb 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/kotlinSignature/SignaturesPropagationData.java +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/kotlinSignature/SignaturesPropagationData.java @@ -116,9 +116,7 @@ public class SignaturesPropagationData { autoValueParameters, autoReturnType, Modality.OPEN, - Visibilities.PUBLIC, - false, - false + Visibilities.PUBLIC ); return autoMethodDescriptor; } diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/synthetic/SamAdapterFunctionsScope.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/synthetic/SamAdapterFunctionsScope.kt index 0b497889422..532fe87f9bc 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/synthetic/SamAdapterFunctionsScope.kt +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/synthetic/SamAdapterFunctionsScope.kt @@ -129,7 +129,7 @@ class SamAdapterFunctionsScope(storageManager: StorageManager) : JetScope by Jet val visibility = syntheticExtensionVisibility(sourceFunction) descriptor.initialize(receiverType, null, typeParameters, valueParameters, returnType, - Modality.FINAL, visibility, false, false) + Modality.FINAL, visibility) return descriptor } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java index 3d0d2abafc8..26a129fba8b 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java @@ -36,6 +36,7 @@ import org.jetbrains.kotlin.resolve.varianceChecker.VarianceChecker.VarianceConf import org.jetbrains.kotlin.types.JetType; import org.jetbrains.kotlin.types.expressions.OperatorConventions; import org.jetbrains.kotlin.util.MappedExtensionProvider; +import org.jetbrains.kotlin.util.OperatorNameConventions; import java.lang.reflect.Field; import java.lang.reflect.Modifier; @@ -560,7 +561,7 @@ public class DefaultErrorMessages { MAP.put(CONFLICTING_OVERLOADS, "''{0}'' is already defined in {1}", COMPACT_WITH_MODIFIERS, STRING); MAP.put(FUNCTION_EXPECTED, "Expression ''{0}''{1} cannot be invoked as a function. " + - "The function '" + OperatorConventions.INVOKE.asString() + "()' is not found", + "The function '" + OperatorNameConventions.INVOKE.asString() + "()' is not found", ELEMENT_TEXT, new Renderer() { @NotNull @Override diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java index faddf5748c8..d0c307a7139 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java @@ -242,10 +242,9 @@ public class DescriptorResolver { Collections.emptyList(), returnType, Modality.FINAL, - property.getVisibility(), - true, - false + property.getVisibility() ); + functionDescriptor.setOperator(true); trace.record(BindingContext.DATA_CLASS_COMPONENT_FUNCTION, parameter, functionDescriptor); @@ -292,9 +291,7 @@ public class DescriptorResolver { parameterDescriptors, returnType, Modality.FINAL, - Visibilities.PUBLIC, - false, - false + Visibilities.PUBLIC ); trace.record(BindingContext.DATA_CLASS_COPY_FUNCTION, classDescriptor, functionDescriptor); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionDescriptorResolver.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionDescriptorResolver.kt index e03fa7d0aed..0ba6463d464 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionDescriptorResolver.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionDescriptorResolver.kt @@ -172,10 +172,10 @@ class FunctionDescriptorResolver( valueParameterDescriptors, returnType, modality, - visibility, - function.hasModifier(JetTokens.OPERATOR_KEYWORD), - function.hasModifier(JetTokens.INFIX_KEYWORD) + visibility ) + functionDescriptor.isOperator = function.hasModifier(JetTokens.OPERATOR_KEYWORD) + functionDescriptor.isInfix = function.hasModifier(JetTokens.INFIX_KEYWORD) receiverType?.let { ForceResolveUtil.forceResolveAllContents(it.getAnnotations()) } for (valueParameterDescriptor in valueParameterDescriptors) { ForceResolveUtil.forceResolveAllContents(valueParameterDescriptor.getType().getAnnotations()) diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionDescriptorUtil.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionDescriptorUtil.java index 90949c7db8f..2cfb4f6339c 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionDescriptorUtil.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionDescriptorUtil.java @@ -103,9 +103,7 @@ public class FunctionDescriptorUtil { KotlinBuiltIns.getValueParameters(functionDescriptor, functionType), KotlinBuiltIns.getReturnTypeFromFunctionType(functionType), modality, - visibility, - false, - false); + visibility); } public static D alphaConvertTypeParameters(D candidate) { @@ -157,9 +155,9 @@ public class FunctionDescriptorUtil { parameters, function.getReturnType(), function.getModality(), - function.getVisibility(), - function.isOperator(), - function.isInfix()); + function.getVisibility()); + descriptor.setOperator(function.isOperator()); + descriptor.setInfix(function.isInfix()); return descriptor; } } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/OperatorModifierChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/OperatorModifierChecker.kt index 8efa089ee96..38364272c1a 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/OperatorModifierChecker.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/OperatorModifierChecker.kt @@ -38,7 +38,7 @@ import org.jetbrains.kotlin.diagnostics.DiagnosticSink import org.jetbrains.kotlin.diagnostics.Errors import org.jetbrains.kotlin.lexer.JetTokens import org.jetbrains.kotlin.psi.JetDeclaration -import org.jetbrains.kotlin.types.expressions.OperatorConventions.* +import org.jetbrains.kotlin.util.OperatorNameConventions public class OperatorModifierChecker : DeclarationChecker { override fun check( @@ -51,23 +51,8 @@ public class OperatorModifierChecker : DeclarationChecker { if (!functionDescriptor.isOperator) return val modifier = declaration.modifierList?.getModifier(JetTokens.OPERATOR_KEYWORD) ?: return - val name = functionDescriptor.name - - when { - GET == name -> {} - SET == name -> {} - INVOKE == name -> {} - CONTAINS == name -> {} - ITERATOR == name -> {} - NEXT == name -> {} - HAS_NEXT == name -> {} - EQUALS == name -> {} - COMPARE_TO == name -> {} - UNARY_OPERATION_NAMES.any { it.value == name } && functionDescriptor.valueParameters.isEmpty() -> {} - BINARY_OPERATION_NAMES.any { it.value == name } && functionDescriptor.valueParameters.size() == 1 -> {} - ASSIGNMENT_OPERATIONS.any { it.value == name } -> {} - name.asString().matches(COMPONENT_REGEX) -> {} - else -> diagnosticHolder.report(Errors.INAPPLICABLE_OPERATOR_MODIFIER.on(modifier)) + if (!OperatorNameConventions.canBeOperator(functionDescriptor)) { + diagnosticHolder.report(Errors.INAPPLICABLE_OPERATOR_MODIFIER.on(modifier)) } } } \ No newline at end of file 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 877acc8b075..986b74530b7 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolver.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolver.java @@ -54,7 +54,7 @@ import org.jetbrains.kotlin.types.TypeSubstitutor; import org.jetbrains.kotlin.types.expressions.ExpressionTypingContext; import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices; import org.jetbrains.kotlin.types.expressions.ExpressionTypingVisitorDispatcher; -import org.jetbrains.kotlin.types.expressions.OperatorConventions; +import org.jetbrains.kotlin.util.OperatorNameConventions; import org.jetbrains.kotlin.util.PerformanceCounter; import javax.inject.Inject; @@ -183,7 +183,7 @@ public class CallResolver { @NotNull TracingStrategy tracing ) { return computeTasksAndResolveCall( - context, OperatorConventions.INVOKE, tracing, + context, OperatorNameConventions.INVOKE, tracing, CallableDescriptorCollectors.FUNCTIONS, CallTransformer.FUNCTION_CALL_TRANSFORMER); } 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 f87fb75d18d..38aea343b96 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallTransformer.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallTransformer.java @@ -46,7 +46,7 @@ import org.jetbrains.kotlin.resolve.calls.util.DelegatingCall; import org.jetbrains.kotlin.resolve.scopes.receivers.ExpressionReceiver; import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue; import org.jetbrains.kotlin.types.JetType; -import org.jetbrains.kotlin.types.expressions.OperatorConventions; +import org.jetbrains.kotlin.util.OperatorNameConventions; import java.util.Collection; import java.util.Collections; @@ -277,7 +277,8 @@ public class CallTransformer { this.explicitExtensionReceiver = explicitExtensionReceiver; this.calleeExpressionAsDispatchReceiver = calleeExpressionAsDispatchReceiver; this.fakeInvokeExpression = - (JetSimpleNameExpression) JetPsiFactory(call.getCallElement()).createExpression(OperatorConventions.INVOKE.asString()); + (JetSimpleNameExpression) JetPsiFactory(call.getCallElement()) + .createExpression(OperatorNameConventions.INVOKE.asString()); } @Nullable diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/InlineChecker.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/InlineChecker.java index 065189225b9..da16c9b6e5e 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/InlineChecker.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/InlineChecker.java @@ -35,7 +35,7 @@ import org.jetbrains.kotlin.resolve.inline.InlineUtil; import org.jetbrains.kotlin.resolve.scopes.receivers.ExpressionReceiver; import org.jetbrains.kotlin.resolve.scopes.receivers.ExtensionReceiver; import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue; -import org.jetbrains.kotlin.types.expressions.OperatorConventions; +import org.jetbrains.kotlin.util.OperatorNameConventions; import java.util.LinkedHashSet; import java.util.Map; @@ -228,7 +228,7 @@ class InlineChecker implements CallChecker { } DeclarationDescriptor containingDeclaration = descriptor.getContainingDeclaration(); - boolean isInvoke = descriptor.getName().equals(OperatorConventions.INVOKE) && + boolean isInvoke = descriptor.getName().equals(OperatorNameConventions.INVOKE) && containingDeclaration instanceof ClassDescriptor && KotlinBuiltIns.isExactFunctionOrExtensionFunctionType(((ClassDescriptor) containingDeclaration).getDefaultType()); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/CallableDescriptorCollectors.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/CallableDescriptorCollectors.kt index fdc51f440b5..7cdc9360ef0 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/CallableDescriptorCollectors.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/CallableDescriptorCollectors.kt @@ -32,7 +32,7 @@ import org.jetbrains.kotlin.resolve.scopes.utils.collectAllFromMeAndParent import org.jetbrains.kotlin.resolve.scopes.utils.getLocalVariable import org.jetbrains.kotlin.types.ErrorUtils import org.jetbrains.kotlin.types.JetType -import org.jetbrains.kotlin.types.expressions.OperatorConventions +import org.jetbrains.kotlin.util.OperatorNameConventions import org.jetbrains.kotlin.utils.singletonOrEmptyList public interface CallableDescriptorCollector { @@ -97,7 +97,7 @@ private object FunctionCollector : CallableDescriptorCollector): Collection { @@ -80,16 +80,16 @@ private fun createSynthesizedFunctionWithFirstParameterAsReceiver(descriptor: Fu }, original.getReturnType(), original.getModality(), - original.getVisibility(), - original.isOperator, - original.isInfix + original.getVisibility() ) + result.isOperator = original.isOperator + result.isInfix = original.isInfix return result } fun isSynthesizedInvoke(descriptor: DeclarationDescriptor): Boolean { - if (descriptor.getName() != OperatorConventions.INVOKE || descriptor !is FunctionDescriptor) return false + if (descriptor.getName() != OperatorNameConventions.INVOKE || descriptor !is FunctionDescriptor) return false var real: FunctionDescriptor = descriptor while (!real.getKind().isReal()) { diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/constants/evaluate/ConstantExpressionEvaluator.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/constants/evaluate/ConstantExpressionEvaluator.kt index 501473907db..5cae1a6237d 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/constants/evaluate/ConstantExpressionEvaluator.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/constants/evaluate/ConstantExpressionEvaluator.kt @@ -35,6 +35,7 @@ import org.jetbrains.kotlin.types.JetType import org.jetbrains.kotlin.types.TypeUtils import org.jetbrains.kotlin.types.checker.JetTypeChecker import org.jetbrains.kotlin.types.expressions.OperatorConventions +import org.jetbrains.kotlin.util.OperatorNameConventions import java.math.BigInteger import java.util.* @@ -425,8 +426,8 @@ private class ConstantExpressionEvaluatorVisitor( val usesNonConstValAsConstant = usesNonConstValAsConstant(argumentForReceiver.expression) || usesNonConstValAsConstant(argumentForParameter.expression) val parameters = CompileTimeConstant.Parameters(canBeUsedInAnnotation, areArgumentsPure, usesVariableAsConstant, usesNonConstValAsConstant) return when (resultingDescriptorName) { - OperatorConventions.COMPARE_TO -> createCompileTimeConstantForCompareTo(result, callExpression, factory)?.wrap(parameters) - OperatorConventions.EQUALS -> createCompileTimeConstantForEquals(result, callExpression, factory)?.wrap(parameters) + OperatorNameConventions.COMPARE_TO -> createCompileTimeConstantForCompareTo(result, callExpression, factory)?.wrap(parameters) + OperatorNameConventions.EQUALS -> createCompileTimeConstantForEquals(result, callExpression, factory)?.wrap(parameters) else -> { createConstant(result, expectedType, parameters) } @@ -796,7 +797,7 @@ private fun createCompileTimeConstantForEquals(result: Any?, operationReference: JetTokens.EQEQ -> result JetTokens.EXCLEQ -> !result JetTokens.IDENTIFIER -> { - assert(operationReference.getReferencedNameAsName() == OperatorConventions.EQUALS) { "This method should be called only for equals operations" } + assert(operationReference.getReferencedNameAsName() == OperatorNameConventions.EQUALS) { "This method should be called only for equals operations" } result } else -> throw IllegalStateException("Unknown equals operation token: $operationToken ${operationReference.getText()}") @@ -816,7 +817,7 @@ private fun createCompileTimeConstantForCompareTo(result: Any?, operationReferen JetTokens.GT -> factory.createBooleanValue(result > 0) JetTokens.GTEQ -> factory.createBooleanValue(result >= 0) JetTokens.IDENTIFIER -> { - assert(operationReference.getReferencedNameAsName() == OperatorConventions.COMPARE_TO) { "This method should be called only for compareTo operations" } + assert(operationReference.getReferencedNameAsName() == OperatorNameConventions.COMPARE_TO) { "This method should be called only for compareTo operations" } return factory.createIntValue(result) } else -> throw IllegalStateException("Unknown compareTo operation token: $operationToken") 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 163ce222b4c..c25d28f6b62 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java @@ -64,6 +64,7 @@ import org.jetbrains.kotlin.types.*; import org.jetbrains.kotlin.types.checker.JetTypeChecker; import org.jetbrains.kotlin.types.expressions.typeInfoFactory.TypeInfoFactoryPackage; import org.jetbrains.kotlin.types.expressions.unqualifiedSuper.UnqualifiedSuperPackage; +import org.jetbrains.kotlin.util.OperatorNameConventions; import org.jetbrains.kotlin.util.slicedMap.WritableSlice; import java.util.Collection; @@ -1066,7 +1067,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { Collections.singletonList(right) ); OverloadResolutionResults resolutionResults = - components.callResolver.resolveCallWithGivenName(newContext, call, operationSign, OperatorConventions.EQUALS); + components.callResolver.resolveCallWithGivenName(newContext, call, operationSign, OperatorNameConventions.EQUALS); traceInterpretingRightAsNullableAny.commit(new TraceEntryFilter() { @Override @@ -1085,7 +1086,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { if (resolutionResults.isSuccess()) { FunctionDescriptor equals = resolutionResults.getResultingCall().getResultingDescriptor(); - if (ensureBooleanResult(operationSign, OperatorConventions.EQUALS, equals.getReturnType(), + if (ensureBooleanResult(operationSign, OperatorNameConventions.EQUALS, equals.getReturnType(), context)) { ensureNonemptyIntersectionOfOperandTypes(expression, context); } @@ -1107,7 +1108,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { @NotNull ExpressionTypingContext context, @NotNull JetSimpleNameExpression operationSign ) { - JetTypeInfo typeInfo = getTypeInfoForBinaryCall(OperatorConventions.COMPARE_TO, context, expression); + JetTypeInfo typeInfo = getTypeInfoForBinaryCall(OperatorNameConventions.COMPARE_TO, context, expression); JetType compareToReturnType = typeInfo.getType(); JetType type = null; if (compareToReturnType != null && !compareToReturnType.isError()) { @@ -1237,9 +1238,9 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { contextWithDataFlow, CallMaker.makeCall(callElement, receiver, null, operationSign, Collections.singletonList(leftArgument)), operationSign, - OperatorConventions.CONTAINS); + OperatorNameConventions.CONTAINS); JetType containsType = OverloadResolutionResultsUtil.getResultingType(resolutionResult, context.contextDependency); - ensureBooleanResult(operationSign, OperatorConventions.CONTAINS, containsType, context); + ensureBooleanResult(operationSign, OperatorNameConventions.CONTAINS, containsType, context); if (left != null) { dataFlowInfo = facade.getTypeInfo(left, contextWithDataFlow).getDataFlowInfo().and(dataFlowInfo); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ControlStructureTypingUtils.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ControlStructureTypingUtils.java index 3c6f889139d..4ce699802a6 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ControlStructureTypingUtils.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ControlStructureTypingUtils.java @@ -129,9 +129,7 @@ public class ControlStructureTypingUtils { valueParameters, type, Modality.FINAL, - Visibilities.PUBLIC, - false, - false + Visibilities.PUBLIC ); return function; } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/OperatorConventions.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/OperatorConventions.java index c6526670977..cd3ee35846b 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/OperatorConventions.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/OperatorConventions.java @@ -18,28 +18,16 @@ package org.jetbrains.kotlin.types.expressions; import com.google.common.collect.ImmutableBiMap; import com.google.common.collect.ImmutableSet; -import kotlin.text.Regex; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.kotlin.lexer.JetSingleValueToken; import org.jetbrains.kotlin.lexer.JetToken; import org.jetbrains.kotlin.lexer.JetTokens; import org.jetbrains.kotlin.name.Name; +import static org.jetbrains.kotlin.util.OperatorNameConventions.*; public class OperatorConventions { - public static final Name EQUALS = Name.identifier("equals"); - public static final Name IDENTITY_EQUALS = Name.identifier("identityEquals"); - public static final Name COMPARE_TO = Name.identifier("compareTo"); - public static final Name CONTAINS = Name.identifier("contains"); - public static final Name INVOKE = Name.identifier("invoke"); - public static final Name ITERATOR = Name.identifier("iterator"); - public static final Name GET = Name.identifier("get"); - public static final Name SET = Name.identifier("set"); - public static final Name NEXT = Name.identifier("next"); - public static final Name HAS_NEXT = Name.identifier("hasNext"); - public static final Regex COMPONENT_REGEX = new Regex("component\\d+"); - private OperatorConventions() {} // Names for primitive type conversion properties @@ -56,21 +44,23 @@ public class OperatorConventions { DOUBLE, FLOAT, LONG, INT, SHORT, BYTE, CHAR ); + // If you add new unary, binary or assignment operators, add it to OperatorConventionNames as well + public static final ImmutableBiMap UNARY_OPERATION_NAMES = ImmutableBiMap.builder() - .put(JetTokens.PLUSPLUS, Name.identifier("inc")) - .put(JetTokens.MINUSMINUS, Name.identifier("dec")) - .put(JetTokens.PLUS, Name.identifier("plus")) - .put(JetTokens.MINUS, Name.identifier("minus")) - .put(JetTokens.EXCL, Name.identifier("not")) + .put(JetTokens.PLUSPLUS, INC) + .put(JetTokens.MINUSMINUS, DEC) + .put(JetTokens.PLUS, PLUS) + .put(JetTokens.MINUS, MINUS) + .put(JetTokens.EXCL, NOT) .build(); public static final ImmutableBiMap BINARY_OPERATION_NAMES = ImmutableBiMap.builder() - .put(JetTokens.MUL, Name.identifier("times")) - .put(JetTokens.PLUS, Name.identifier("plus")) - .put(JetTokens.MINUS, Name.identifier("minus")) - .put(JetTokens.DIV, Name.identifier("div")) - .put(JetTokens.PERC, Name.identifier("mod")) - .put(JetTokens.RANGE, Name.identifier("rangeTo")) + .put(JetTokens.MUL, TIMES) + .put(JetTokens.PLUS, PLUS) + .put(JetTokens.MINUS, MINUS) + .put(JetTokens.DIV, DIV) + .put(JetTokens.PERC, MOD) + .put(JetTokens.RANGE, RANGE_TO) .build(); public static final ImmutableSet NOT_OVERLOADABLE = @@ -92,11 +82,11 @@ public class OperatorConventions { ImmutableSet.of(JetTokens.IN_KEYWORD, JetTokens.NOT_IN); public static final ImmutableBiMap ASSIGNMENT_OPERATIONS = ImmutableBiMap.builder() - .put(JetTokens.MULTEQ, Name.identifier("timesAssign")) - .put(JetTokens.DIVEQ, Name.identifier("divAssign")) - .put(JetTokens.PERCEQ, Name.identifier("modAssign")) - .put(JetTokens.PLUSEQ, Name.identifier("plusAssign")) - .put(JetTokens.MINUSEQ, Name.identifier("minusAssign")) + .put(JetTokens.MULTEQ, TIMES_ASSIGN) + .put(JetTokens.DIVEQ, DIV_ASSIGN) + .put(JetTokens.PERCEQ, MOD_ASSIGN) + .put(JetTokens.PLUSEQ, PLUS_ASSIGN) + .put(JetTokens.MINUSEQ, MINUS_ASSIGN) .build(); public static final ImmutableBiMap ASSIGNMENT_OPERATION_COUNTERPARTS = ImmutableBiMap.builder() @@ -108,8 +98,8 @@ public class OperatorConventions { .build(); public static final ImmutableBiMap BOOLEAN_OPERATIONS = ImmutableBiMap.builder() - .put(JetTokens.ANDAND, Name.identifier("and")) - .put(JetTokens.OROR, Name.identifier("or")) + .put(JetTokens.ANDAND, AND) + .put(JetTokens.OROR, OR) .build(); public static final ImmutableSet CONVENTION_NAMES = ImmutableSet.builder() diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/delegatedProperties.txt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/delegatedProperties.txt index f073eef21a7..b65523c68d5 100644 --- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/delegatedProperties.txt +++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/delegatedProperties.txt @@ -12,9 +12,9 @@ public open class J { public interface DP { public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean - public abstract fun get(/*0*/ a: kotlin.Any!, /*1*/ b: kotlin.Any!): kotlin.String! + public abstract operator fun get(/*0*/ a: kotlin.Any!, /*1*/ b: kotlin.Any!): kotlin.String! public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int - public abstract fun set(/*0*/ a: kotlin.Any!, /*1*/ b: kotlin.Any!, /*2*/ c: kotlin.Any!): kotlin.String! + public abstract operator fun set(/*0*/ a: kotlin.Any!, /*1*/ b: kotlin.Any!, /*2*/ c: kotlin.Any!): kotlin.String! public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/invoke.kt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/invoke.kt index 4b96ed0b427..f858bc8d56f 100644 --- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/invoke.kt +++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/invoke.kt @@ -17,7 +17,7 @@ public class J { // FILE: k.kt fun test() { - J.staticNN() - J.staticN() - J.staticJ() + J.staticNN() + J.staticN() + J.staticJ() } \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/invoke.txt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/invoke.txt index 936950913b2..c6bbd9e7644 100644 --- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/invoke.txt +++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/invoke.txt @@ -11,7 +11,7 @@ public open class J { public interface Invoke { public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int - public abstract fun invoke(): kotlin.Unit + public abstract operator fun invoke(): kotlin.Unit public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/multiDeclaration.kt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/multiDeclaration.kt index 0fe77165de8..6ef4f06acd5 100644 --- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/multiDeclaration.kt +++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/multiDeclaration.kt @@ -26,7 +26,7 @@ fun test() { // platform type with no annotation val platformJ = J.staticJ - val (a1, b1) = platformNN + val (a1, b1) = platformNN val (a2, b2) = platformN - val (a3, b3) = platformJ + val (a3, b3) = platformJ } \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/multiDeclaration.txt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/multiDeclaration.txt index 9ca50c4fe53..edc3bb1401f 100644 --- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/multiDeclaration.txt +++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/multiDeclaration.txt @@ -9,8 +9,8 @@ public open class J { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String public interface Multi { - public abstract fun component1(): kotlin.String! - public abstract fun component2(): kotlin.String! + public abstract operator fun component1(): kotlin.String! + public abstract operator fun component2(): kotlin.String! public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/passToJava.txt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/passToJava.txt index 9ebfa1b8f55..e19fc1f5645 100644 --- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/passToJava.txt +++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/passToJava.txt @@ -10,7 +10,7 @@ public open class J { @org.jetbrains.annotations.NotNull() public final var nn: J public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int - public open fun set(/*0*/ @org.jetbrains.annotations.NotNull() nn: J, /*1*/ @org.jetbrains.annotations.Nullable() n: J?, /*2*/ j: J!): kotlin.Unit + public open operator fun set(/*0*/ @org.jetbrains.annotations.NotNull() nn: J, /*1*/ @org.jetbrains.annotations.Nullable() n: J?, /*2*/ j: J!): kotlin.Unit public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String // Static members diff --git a/compiler/testData/loadJava/compiledJava/InnerClassesInGeneric.txt b/compiler/testData/loadJava/compiledJava/InnerClassesInGeneric.txt index 51954261ccb..906bdfee6f0 100644 --- a/compiler/testData/loadJava/compiledJava/InnerClassesInGeneric.txt +++ b/compiler/testData/loadJava/compiledJava/InnerClassesInGeneric.txt @@ -9,6 +9,6 @@ public open class InnerClassesInGeneric! + public open operator fun iterator(): kotlin.(Mutable)Iterator! } } diff --git a/compiler/testData/loadJava/compiledJava/InnerOfGeneric.txt b/compiler/testData/loadJava/compiledJava/InnerOfGeneric.txt index f022d8b3f85..90a6ee865fa 100644 --- a/compiler/testData/loadJava/compiledJava/InnerOfGeneric.txt +++ b/compiler/testData/loadJava/compiledJava/InnerOfGeneric.txt @@ -23,6 +23,6 @@ public open class InnerOfGeneric { public open inner class S { public constructor S() - public open fun iterator(): kotlin.(Mutable)Iterator! + public open operator fun iterator(): kotlin.(Mutable)Iterator! } } diff --git a/compiler/testData/loadJava/compiledJava/signaturePropagation/ReturnInnerSubclassOfSupersInner.txt b/compiler/testData/loadJava/compiledJava/signaturePropagation/ReturnInnerSubclassOfSupersInner.txt index 3aff37ed373..880ae8c0437 100644 --- a/compiler/testData/loadJava/compiledJava/signaturePropagation/ReturnInnerSubclassOfSupersInner.txt +++ b/compiler/testData/loadJava/compiledJava/signaturePropagation/ReturnInnerSubclassOfSupersInner.txt @@ -16,7 +16,7 @@ public interface ReturnInnerSubclassOfSupersInner { public/*package*/ open inner class Inner { public/*package*/ constructor Inner() - public/*package*/ open fun get(): test.ReturnInnerSubclassOfSupersInner.Super! + public/*package*/ open operator fun get(): test.ReturnInnerSubclassOfSupersInner.Super! } } } diff --git a/compiler/testData/loadJava/sourceJava/ReturnInnerSubclassOfSupersInner.txt b/compiler/testData/loadJava/sourceJava/ReturnInnerSubclassOfSupersInner.txt index 3aff37ed373..880ae8c0437 100644 --- a/compiler/testData/loadJava/sourceJava/ReturnInnerSubclassOfSupersInner.txt +++ b/compiler/testData/loadJava/sourceJava/ReturnInnerSubclassOfSupersInner.txt @@ -16,7 +16,7 @@ public interface ReturnInnerSubclassOfSupersInner { public/*package*/ open inner class Inner { public/*package*/ constructor Inner() - public/*package*/ open fun get(): test.ReturnInnerSubclassOfSupersInner.Super! + public/*package*/ open operator fun get(): test.ReturnInnerSubclassOfSupersInner.Super! } } } diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/descriptors/JavaConstructorDescriptor.java b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/descriptors/JavaConstructorDescriptor.java index d8e8d65fabd..4343f749847 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/descriptors/JavaConstructorDescriptor.java +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/descriptors/JavaConstructorDescriptor.java @@ -109,9 +109,7 @@ public class JavaConstructorDescriptor extends ConstructorDescriptorImpl impleme DescriptorsPackage.createEnhancedValueParameters(enhancedValueParametersTypes, getValueParameters(), enhanced), enhancedReturnType, getModality(), - getVisibility(), - false, - false + getVisibility() ); return enhanced; diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/descriptors/JavaMethodDescriptor.java b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/descriptors/JavaMethodDescriptor.java index 2ab58063bf6..1123c8bfcee 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/descriptors/JavaMethodDescriptor.java +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/descriptors/JavaMethodDescriptor.java @@ -24,6 +24,7 @@ import org.jetbrains.kotlin.descriptors.impl.SimpleFunctionDescriptorImpl; import org.jetbrains.kotlin.name.Name; import org.jetbrains.kotlin.types.JetType; import org.jetbrains.kotlin.types.TypeSubstitutor; +import org.jetbrains.kotlin.util.OperatorNameConventions; import java.util.List; @@ -73,6 +74,24 @@ public class JavaMethodDescriptor extends SimpleFunctionDescriptorImpl implement return new JavaMethodDescriptor(containingDeclaration, null, annotations, name, Kind.DECLARATION, source); } + @NotNull + @Override + public SimpleFunctionDescriptorImpl initialize( + @Nullable JetType receiverParameterType, + @Nullable ReceiverParameterDescriptor dispatchReceiverParameter, + @NotNull List typeParameters, + @NotNull List unsubstitutedValueParameters, + @Nullable JetType unsubstitutedReturnType, + @Nullable Modality modality, + @NotNull Visibility visibility + ) { + SimpleFunctionDescriptorImpl descriptor = super.initialize( + receiverParameterType, dispatchReceiverParameter, typeParameters, unsubstitutedValueParameters, + unsubstitutedReturnType, modality, visibility); + setOperator(OperatorNameConventions.INSTANCE$.canBeOperator(descriptor)); + return descriptor; + } + @Override public boolean hasStableParameterNames() { assert parameterNamesStatus != null : "Parameter names status was not set: " + this; @@ -122,7 +141,7 @@ public class JavaMethodDescriptor extends SimpleFunctionDescriptorImpl implement // 1. creates full copy of descriptor // 2. copies method's type parameters (with new containing declaration) and properly substitute to them in value parameters, return type and etc. JavaMethodDescriptor enhancedMethod = (JavaMethodDescriptor) doSubstitute( - TypeSubstitutor.EMPTY, getContainingDeclaration(), getModality(), getVisibility(), false, false, getOriginal(), + TypeSubstitutor.EMPTY, getContainingDeclaration(), getModality(), getVisibility(), isOperator(), isInfix(), getOriginal(), /* copyOverrides = */ true, getKind(), enhancedValueParameters, enhancedReceiverType, enhancedReturnType ); diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaScope.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaScope.kt index b80452adbbd..8643ac6661d 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaScope.kt +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaScope.kt @@ -131,9 +131,7 @@ public abstract class LazyJavaScope( effectiveSignature.getValueParameters(), effectiveSignature.getReturnType(), Modality.convertFromFlags(method.isAbstract(), !method.isFinal()), - method.getVisibility(), - false, - false + method.getVisibility() ) functionDescriptorImpl.setParameterNamesStatus(effectiveSignature.hasStableParameterNames(), valueParameters.hasSynthesizedNames) diff --git a/core/descriptors/src/org/jetbrains/kotlin/builtins/functions/FunctionInvokeDescriptor.kt b/core/descriptors/src/org/jetbrains/kotlin/builtins/functions/FunctionInvokeDescriptor.kt index 67358a45111..b7103583f5f 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/builtins/functions/FunctionInvokeDescriptor.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/builtins/functions/FunctionInvokeDescriptor.kt @@ -60,10 +60,9 @@ public class FunctionInvokeDescriptor private constructor( .map { createValueParameter(result, it.index, it.value) }, typeParameters.last().getDefaultType(), Modality.ABSTRACT, - Visibilities.PUBLIC, - true, - false + Visibilities.PUBLIC ) + result.isOperator = true return result } diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/ConstructorDescriptorImpl.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/ConstructorDescriptorImpl.java index 553b513f0b7..19349152458 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/ConstructorDescriptorImpl.java +++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/ConstructorDescriptorImpl.java @@ -60,7 +60,7 @@ public class ConstructorDescriptorImpl extends FunctionDescriptorImpl implements @NotNull Visibility visibility ) { super.initialize(null, calculateDispatchReceiverParameter(), typeParameters, unsubstitutedValueParameters, null, - Modality.FINAL, visibility, false, false); + Modality.FINAL, visibility); return this; } diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/FunctionDescriptorImpl.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/FunctionDescriptorImpl.java index 425487d7287..d066e1fd20a 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/FunctionDescriptorImpl.java +++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/FunctionDescriptorImpl.java @@ -42,8 +42,8 @@ public abstract class FunctionDescriptorImpl extends DeclarationDescriptorNonRoo private ReceiverParameterDescriptor dispatchReceiverParameter; private Modality modality; private Visibility visibility = Visibilities.UNKNOWN; - private boolean isOperator; - private boolean isInfix; + private boolean isOperator = false; + private boolean isInfix = false; private final Set overriddenFunctions = SmartSet.create(); private final FunctionDescriptor original; private final Kind kind; @@ -69,17 +69,13 @@ public abstract class FunctionDescriptorImpl extends DeclarationDescriptorNonRoo @NotNull List unsubstitutedValueParameters, @Nullable JetType unsubstitutedReturnType, @Nullable Modality modality, - @NotNull Visibility visibility, - boolean isOperator, - boolean isInfix + @NotNull Visibility visibility ) { this.typeParameters = UtilsPackage.toReadOnlyList(typeParameters); this.unsubstitutedValueParameters = unsubstitutedValueParameters; this.unsubstitutedReturnType = unsubstitutedReturnType; this.modality = modality; this.visibility = visibility; - this.isOperator = isOperator; - this.isInfix = isInfix; this.extensionReceiverParameter = DescriptorFactory.createExtensionReceiverParameterForCallable(this, receiverParameterType); this.dispatchReceiverParameter = dispatchReceiverParameter; @@ -106,6 +102,14 @@ public abstract class FunctionDescriptorImpl extends DeclarationDescriptorNonRoo this.visibility = visibility; } + public void setOperator(boolean isOperator) { + this.isOperator = isOperator; + } + + public void setInfix(boolean isInfix) { + this.isInfix = isInfix; + } + public void setReturnType(@NotNull JetType unsubstitutedReturnType) { if (this.unsubstitutedReturnType != null) { // TODO: uncomment and fix tests @@ -309,10 +313,10 @@ public abstract class FunctionDescriptorImpl extends DeclarationDescriptorNonRoo substitutedValueParameters, substitutedReturnType, newModality, - newVisibility, - isOperator, - isInfix + newVisibility ); + substitutedDescriptor.setOperator(isOperator); + substitutedDescriptor.setInfix(isInfix); if (copyOverrides) { for (FunctionDescriptor overriddenFunction : overriddenFunctions) { diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/ScriptCodeDescriptor.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/ScriptCodeDescriptor.java index c2f47e7345f..99c17c0e5b6 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/ScriptCodeDescriptor.java +++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/ScriptCodeDescriptor.java @@ -37,7 +37,7 @@ public class ScriptCodeDescriptor extends FunctionDescriptorImpl { @NotNull List valueParameters, @NotNull JetType returnType) { super.initialize(null, dispatchReceiverParameter, Collections.emptyList(), valueParameters, returnType, - Modality.FINAL, Visibilities.INTERNAL, false, false); + Modality.FINAL, Visibilities.INTERNAL); } @NotNull diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/SimpleFunctionDescriptorImpl.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/SimpleFunctionDescriptorImpl.java index 9c8cd0214f4..bbd824ef4a7 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/SimpleFunctionDescriptorImpl.java +++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/SimpleFunctionDescriptorImpl.java @@ -58,12 +58,10 @@ public class SimpleFunctionDescriptorImpl extends FunctionDescriptorImpl impleme @NotNull List unsubstitutedValueParameters, @Nullable JetType unsubstitutedReturnType, @Nullable Modality modality, - @NotNull Visibility visibility, - boolean isOperator, - boolean isInfix + @NotNull Visibility visibility ) { super.initialize(receiverParameterType, dispatchReceiverParameter, typeParameters, unsubstitutedValueParameters, - unsubstitutedReturnType, modality, visibility, isOperator, isInfix); + unsubstitutedReturnType, modality, visibility); return this; } diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/DescriptorFactory.java b/core/descriptors/src/org/jetbrains/kotlin/resolve/DescriptorFactory.java index 81f96c33e0f..05dfacdf3d0 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/resolve/DescriptorFactory.java +++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/DescriptorFactory.java @@ -103,7 +103,7 @@ public class DescriptorFactory { return values.initialize(null, null, Collections.emptyList(), Collections.emptyList(), getBuiltIns(enumClass).getArrayType(Variance.INVARIANT, enumClass.getDefaultType()), - Modality.FINAL, Visibilities.PUBLIC, false, false); + Modality.FINAL, Visibilities.PUBLIC); } @NotNull @@ -117,7 +117,7 @@ public class DescriptorFactory { ); return valueOf.initialize(null, null, Collections.emptyList(), Collections.singletonList(parameterDescriptor), enumClass.getDefaultType(), - Modality.FINAL, Visibilities.PUBLIC, false, false); + Modality.FINAL, Visibilities.PUBLIC); } @Nullable diff --git a/core/descriptors/src/org/jetbrains/kotlin/types/ErrorUtils.java b/core/descriptors/src/org/jetbrains/kotlin/types/ErrorUtils.java index eebe0c3924b..8bced5e135b 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/types/ErrorUtils.java +++ b/core/descriptors/src/org/jetbrains/kotlin/types/ErrorUtils.java @@ -499,9 +499,7 @@ public class ErrorUtils { Collections.emptyList(), // TODO createErrorType(""), Modality.OPEN, - Visibilities.INTERNAL, - false, - false + Visibilities.INTERNAL ); return function; } diff --git a/core/descriptors/src/org/jetbrains/kotlin/util/OperatorNameConventions.kt b/core/descriptors/src/org/jetbrains/kotlin/util/OperatorNameConventions.kt new file mode 100644 index 00000000000..20e576fecb3 --- /dev/null +++ b/core/descriptors/src/org/jetbrains/kotlin/util/OperatorNameConventions.kt @@ -0,0 +1,86 @@ +/* + * 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.util + +import org.jetbrains.kotlin.descriptors.FunctionDescriptor +import org.jetbrains.kotlin.name.Name +import kotlin.text.Regex + +object OperatorNameConventions { + + val EQUALS = Name.identifier("equals") + val IDENTITY_EQUALS = Name.identifier("identityEquals"); + val COMPARE_TO = Name.identifier("compareTo") + val CONTAINS = Name.identifier("contains") + val INVOKE = Name.identifier("invoke") + val ITERATOR = Name.identifier("iterator") + val GET = Name.identifier("get") + val SET = Name.identifier("set") + val NEXT = Name.identifier("next") + val HAS_NEXT = Name.identifier("hasNext") + + val COMPONENT_REGEX = Regex("component\\d+") + + val AND = Name.identifier("and") + val OR = Name.identifier("or") + + val INC = Name.identifier("inc") + val DEC = Name.identifier("dec") + val PLUS = Name.identifier("plus") + val MINUS = Name.identifier("minus") + val NOT = Name.identifier("not") + + val TIMES = Name.identifier("times") + val DIV = Name.identifier("div") + val MOD = Name.identifier("mod") + val RANGE_TO = Name.identifier("rangeTo") + + val TIMES_ASSIGN = Name.identifier("timesAssign") + val DIV_ASSIGN = Name.identifier("divAssign") + val MOD_ASSIGN = Name.identifier("modAssign") + val PLUS_ASSIGN = Name.identifier("plusAssign") + val MINUS_ASSIGN = Name.identifier("minusAssign") + + // If you add new unary, binary or assignment operators, add it to OperatorConventions as well + + private val UNARY_OPERATION_NAMES = setOf(INC, DEC, PLUS, MINUS, NOT) + private val BINARY_OPERATION_NAMES = setOf(TIMES, PLUS, MINUS, DIV, MOD, RANGE_TO) + private val ASSIGNMENT_OPERATIONS = setOf(TIMES_ASSIGN, DIV_ASSIGN, MOD_ASSIGN, PLUS_ASSIGN, MINUS_ASSIGN) + + fun canBeOperator(functionDescriptor: FunctionDescriptor): Boolean { + val name = functionDescriptor.name + + return when { + GET == name -> true + SET == name -> true + INVOKE == name -> true + CONTAINS == name -> true + ITERATOR == name -> true + NEXT == name -> true + HAS_NEXT == name -> true + EQUALS == name -> true + COMPARE_TO == name -> true + UNARY_OPERATION_NAMES.any { it == name } && functionDescriptor.valueParameters.isEmpty() -> true + BINARY_OPERATION_NAMES.any { it == name } && functionDescriptor.valueParameters.size() == 1 -> true + ASSIGNMENT_OPERATIONS.any { it == name } -> true + name.asString().matches(COMPONENT_REGEX) -> true + else -> false + } + } + + +} diff --git a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/MemberDeserializer.kt b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/MemberDeserializer.kt index 38c3a592ef1..a8b4cd2b03d 100644 --- a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/MemberDeserializer.kt +++ b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/MemberDeserializer.kt @@ -151,10 +151,10 @@ public class MemberDeserializer(private val c: DeserializationContext) { local.memberDeserializer.valueParameters(proto, AnnotatedCallableKind.FUNCTION), local.typeDeserializer.type(proto.returnType), Deserialization.modality(Flags.MODALITY.get(proto.flags)), - Deserialization.visibility(Flags.VISIBILITY.get(proto.flags)), - Flags.OLD_IS_OPERATOR.get(proto.flags), - Flags.OLD_IS_INFIX.get(proto.flags) + Deserialization.visibility(Flags.VISIBILITY.get(proto.flags)) ) + function.isOperator = Flags.OLD_IS_OPERATOR.get(proto.flags) + function.isInfix = Flags.OLD_IS_INFIX.get(proto.flags) return function } diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/intentions/OperatorToFunctionIntention.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/intentions/OperatorToFunctionIntention.kt index 143a9f76192..b7255380a96 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/intentions/OperatorToFunctionIntention.kt +++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/intentions/OperatorToFunctionIntention.kt @@ -25,7 +25,7 @@ import org.jetbrains.kotlin.psi.* import org.jetbrains.kotlin.psi.psiUtil.getQualifiedElementSelector import org.jetbrains.kotlin.resolve.calls.callUtil.getResolvedCall import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode -import org.jetbrains.kotlin.types.expressions.OperatorConventions +import org.jetbrains.kotlin.util.OperatorNameConventions public class OperatorToFunctionIntention : JetSelfTargetingIntention(javaClass(), "Replace overloaded operator with function call") { companion object { @@ -72,9 +72,9 @@ public class OperatorToFunctionIntention : JetSelfTargetingIntention = ImmutableSet .builder() @@ -37,7 +38,7 @@ public val ALL_SEARCHABLE_OPERATIONS: ImmutableSet = ImmutableSet .add(JetTokens.BY_KEYWORD) .build() -public val INDEXING_OPERATION_NAMES = setOf(GET, SET) +public val INDEXING_OPERATION_NAMES = setOf(OperatorNameConventions.GET, OperatorNameConventions.SET) public val IN_OPERATIONS_TO_SEARCH = setOf(JetTokens.IN_KEYWORD) @@ -45,11 +46,11 @@ public val COMPARISON_OPERATIONS_TO_SEARCH = setOf(JetTokens.LT, JetTokens.GT) public fun Name.getOperationSymbolsToSearch(): Set { when (this) { - COMPARE_TO -> return COMPARISON_OPERATIONS_TO_SEARCH - EQUALS -> return EQUALS_OPERATIONS - IDENTITY_EQUALS -> return IDENTITY_EQUALS_OPERATIONS - CONTAINS -> return IN_OPERATIONS_TO_SEARCH - ITERATOR -> return IN_OPERATIONS_TO_SEARCH + OperatorNameConventions.COMPARE_TO -> return COMPARISON_OPERATIONS_TO_SEARCH + OperatorNameConventions.EQUALS -> return EQUALS_OPERATIONS + OperatorNameConventions.IDENTITY_EQUALS -> return IDENTITY_EQUALS_OPERATIONS + OperatorNameConventions.CONTAINS -> return IN_OPERATIONS_TO_SEARCH + OperatorNameConventions.ITERATOR -> return IN_OPERATIONS_TO_SEARCH in INDEXING_OPERATION_NAMES -> return setOf(JetTokens.LBRACKET, JetTokens.BY_KEYWORD) DelegatedPropertyResolver.PROPERTY_DELEGATED_FUNCTION_NAME -> return setOf(JetTokens.BY_KEYWORD) } diff --git a/idea/src/org/jetbrains/kotlin/idea/debugger/stepping/KotlinLambdaMethodFilter.kt b/idea/src/org/jetbrains/kotlin/idea/debugger/stepping/KotlinLambdaMethodFilter.kt index 5cccd256c47..16e3de6a848 100644 --- a/idea/src/org/jetbrains/kotlin/idea/debugger/stepping/KotlinLambdaMethodFilter.kt +++ b/idea/src/org/jetbrains/kotlin/idea/debugger/stepping/KotlinLambdaMethodFilter.kt @@ -27,7 +27,7 @@ import com.sun.jdi.Location import org.jetbrains.kotlin.idea.util.application.runReadAction import org.jetbrains.kotlin.psi.JetBlockExpression import org.jetbrains.kotlin.psi.JetFunctionLiteralExpression -import org.jetbrains.kotlin.types.expressions.OperatorConventions +import org.jetbrains.kotlin.util.OperatorNameConventions public class KotlinLambdaMethodFilter( lambda: JetFunctionLiteralExpression, @@ -71,7 +71,7 @@ public class KotlinLambdaMethodFilter( companion object { public fun isLambdaName(name: String?): Boolean { - return name == OperatorConventions.INVOKE.asString() + return name == OperatorNameConventions.INVOKE.asString() } } } \ No newline at end of file diff --git a/idea/src/org/jetbrains/kotlin/idea/debugger/stepping/KotlinLambdaSmartStepIntoTarget.kt b/idea/src/org/jetbrains/kotlin/idea/debugger/stepping/KotlinLambdaSmartStepIntoTarget.kt index 87cfc560890..bcdfb00df1c 100644 --- a/idea/src/org/jetbrains/kotlin/idea/debugger/stepping/KotlinLambdaSmartStepIntoTarget.kt +++ b/idea/src/org/jetbrains/kotlin/idea/debugger/stepping/KotlinLambdaSmartStepIntoTarget.kt @@ -26,7 +26,7 @@ import org.jetbrains.kotlin.idea.JetIcons import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.psi.JetElement import org.jetbrains.kotlin.psi.JetFunctionLiteralExpression -import org.jetbrains.kotlin.types.expressions.OperatorConventions +import org.jetbrains.kotlin.util.OperatorNameConventions import javax.swing.Icon public class KotlinLambdaSmartStepTarget( @@ -40,7 +40,7 @@ public class KotlinLambdaSmartStepTarget( companion object { fun calcLabel(descriptor: DeclarationDescriptor, paramName: Name): String { - return "${descriptor.getName().asString()}: ${paramName.asString()}.${OperatorConventions.INVOKE.asString()}()" + return "${descriptor.getName().asString()}: ${paramName.asString()}.${OperatorNameConventions.INVOKE.asString()}()" } } } \ No newline at end of file diff --git a/idea/src/org/jetbrains/kotlin/idea/highlighter/KotlinRecursiveCallLineMarkerProvider.kt b/idea/src/org/jetbrains/kotlin/idea/highlighter/KotlinRecursiveCallLineMarkerProvider.kt index 044dc170613..e6b2d7d1410 100644 --- a/idea/src/org/jetbrains/kotlin/idea/highlighter/KotlinRecursiveCallLineMarkerProvider.kt +++ b/idea/src/org/jetbrains/kotlin/idea/highlighter/KotlinRecursiveCallLineMarkerProvider.kt @@ -36,6 +36,7 @@ import org.jetbrains.kotlin.resolve.BindingContext import org.jetbrains.kotlin.resolve.inline.InlineUtil import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue import org.jetbrains.kotlin.types.expressions.OperatorConventions +import org.jetbrains.kotlin.util.OperatorNameConventions import java.util.HashSet public class KotlinRecursiveCallLineMarkerProvider() : LineMarkerProvider { @@ -155,7 +156,7 @@ private fun getCallNameFromPsi(element: JetElement): Name? { return Name.identifier("get") is JetThisExpression -> if (element.getParent() is JetCallExpression) { - return OperatorConventions.INVOKE + return OperatorNameConventions.INVOKE } } diff --git a/idea/src/org/jetbrains/kotlin/idea/inspections/OperatorModifierInspection.kt b/idea/src/org/jetbrains/kotlin/idea/inspections/OperatorModifierInspection.kt index 86467645bfb..63a52a1f075 100644 --- a/idea/src/org/jetbrains/kotlin/idea/inspections/OperatorModifierInspection.kt +++ b/idea/src/org/jetbrains/kotlin/idea/inspections/OperatorModifierInspection.kt @@ -43,6 +43,7 @@ import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType import org.jetbrains.kotlin.resolve.OverrideResolver import org.jetbrains.kotlin.resolve.dataClassUtils.isComponentLike import org.jetbrains.kotlin.types.expressions.OperatorConventions +import org.jetbrains.kotlin.util.OperatorNameConventions public class OperatorModifierInspection : AbstractKotlinInspection() { override fun buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean, session: LocalInspectionToolSession): PsiElementVisitor { @@ -67,25 +68,25 @@ public class OperatorModifierInspection : AbstractKotlinInspection() { val arity = valueParameters.size() if (arity == 0 && (name in OperatorConventions.UNARY_OPERATION_NAMES.values() || - name == OperatorConventions.ITERATOR || + name == OperatorNameConventions.ITERATOR || isComponentLike(name) || - name == OperatorConventions.NEXT || - (name == OperatorConventions.HAS_NEXT && isBooleanReturnType()))) { + name == OperatorNameConventions.NEXT || + (name == OperatorNameConventions.HAS_NEXT && isBooleanReturnType()))) { return true } if (arity == 1 && (name in OperatorConventions.BINARY_OPERATION_NAMES.values() || name in OperatorConventions.ASSIGNMENT_OPERATIONS.values () || - (name == OperatorConventions.CONTAINS && isBooleanReturnType()) || - (name == OperatorConventions.COMPARE_TO && isIntReturnType()))) { + (name == OperatorNameConventions.CONTAINS && isBooleanReturnType()) || + (name == OperatorNameConventions.COMPARE_TO && isIntReturnType()))) { return true } - if (name == OperatorConventions.INVOKE) { + if (name == OperatorNameConventions.INVOKE) { return true } - if (arity >= 1 && name == OperatorConventions.GET) { + if (arity >= 1 && name == OperatorNameConventions.GET) { return true } - if (arity >= 2 && name == OperatorConventions.SET) { + if (arity >= 2 && name == OperatorNameConventions.SET) { return true } return false diff --git a/idea/src/org/jetbrains/kotlin/idea/inspections/UnusedSymbolInspection.kt b/idea/src/org/jetbrains/kotlin/idea/inspections/UnusedSymbolInspection.kt index 3fb5fac159c..e73f4d12a85 100644 --- a/idea/src/org/jetbrains/kotlin/idea/inspections/UnusedSymbolInspection.kt +++ b/idea/src/org/jetbrains/kotlin/idea/inspections/UnusedSymbolInspection.kt @@ -58,6 +58,7 @@ import org.jetbrains.kotlin.resolve.BindingContext import org.jetbrains.kotlin.resolve.DescriptorUtils import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode import org.jetbrains.kotlin.types.expressions.OperatorConventions +import org.jetbrains.kotlin.util.OperatorNameConventions import org.jetbrains.kotlin.utils.singletonOrEmptyList import java.awt.GridBagConstraints import java.awt.GridBagLayout @@ -213,7 +214,7 @@ public class UnusedSymbolInspection : AbstractKotlinInspection() { private fun isConventionalName(namedDeclaration: JetNamedDeclaration): Boolean { val name = namedDeclaration.getNameAsName() - return name!!.getOperationSymbolsToSearch().isNotEmpty() || name == OperatorConventions.INVOKE + return name!!.getOperationSymbolsToSearch().isNotEmpty() || name == OperatorNameConventions.INVOKE } private fun hasNonTrivialUsages(declaration: JetNamedDeclaration): Boolean { diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/conventionNameCalls/ReplaceContainsIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/conventionNameCalls/ReplaceContainsIntention.kt index 91a9a456ebb..1f7c6f4b06a 100644 --- a/idea/src/org/jetbrains/kotlin/idea/intentions/conventionNameCalls/ReplaceContainsIntention.kt +++ b/idea/src/org/jetbrains/kotlin/idea/intentions/conventionNameCalls/ReplaceContainsIntention.kt @@ -25,11 +25,11 @@ import org.jetbrains.kotlin.psi.* import org.jetbrains.kotlin.resolve.calls.model.ArgumentMatch import org.jetbrains.kotlin.resolve.calls.model.isReallySuccess import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns -import org.jetbrains.kotlin.types.expressions.OperatorConventions +import org.jetbrains.kotlin.util.OperatorNameConventions public class ReplaceContainsIntention : JetSelfTargetingRangeIntention(javaClass(), "Replace 'contains' call with 'in' operator"), HighPriorityAction { override fun applicabilityRange(element: JetDotQualifiedExpression): TextRange? { - if (element.calleeName != OperatorConventions.CONTAINS.asString()) return null + if (element.calleeName != OperatorNameConventions.CONTAINS.asString()) return null val resolvedCall = element.toResolvedCall() ?: return null if (!resolvedCall.isReallySuccess()) return null diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/conventionNameCalls/ReplaceInvokeIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/conventionNameCalls/ReplaceInvokeIntention.kt index e0676a469a6..ce1c0917162 100644 --- a/idea/src/org/jetbrains/kotlin/idea/intentions/conventionNameCalls/ReplaceInvokeIntention.kt +++ b/idea/src/org/jetbrains/kotlin/idea/intentions/conventionNameCalls/ReplaceInvokeIntention.kt @@ -24,11 +24,11 @@ import org.jetbrains.kotlin.idea.intentions.callExpression import org.jetbrains.kotlin.idea.intentions.calleeName import org.jetbrains.kotlin.psi.JetCallExpression import org.jetbrains.kotlin.psi.JetDotQualifiedExpression -import org.jetbrains.kotlin.types.expressions.OperatorConventions +import org.jetbrains.kotlin.util.OperatorNameConventions public class ReplaceInvokeIntention : JetSelfTargetingRangeIntention(javaClass(), "Replace 'invoke' with direct call"), HighPriorityAction { override fun applicabilityRange(element: JetDotQualifiedExpression): TextRange? { - if (element.calleeName != OperatorConventions.INVOKE.asString()) return null + if (element.calleeName != OperatorNameConventions.INVOKE.asString()) return null return element.callExpression!!.getCalleeExpression()!!.getTextRange() } diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/callableBuilder/CallableBuilder.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/callableBuilder/CallableBuilder.kt index b60e6cda548..fe086994319 100644 --- a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/callableBuilder/CallableBuilder.kt +++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/callableBuilder/CallableBuilder.kt @@ -416,7 +416,7 @@ class CallableBuilder(val config: CallableBuilderConfiguration) { } return fakeFunction.initialize(null, null, typeParameters, Collections.emptyList(), null, - null, Visibilities.INTERNAL, false, false) + null, Visibilities.INTERNAL) } private fun renderTypeCandidates( diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateHasNextFunctionActionFactory.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateHasNextFunctionActionFactory.kt index 0e108d8d19d..9a09c8ac5f4 100644 --- a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateHasNextFunctionActionFactory.kt +++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateHasNextFunctionActionFactory.kt @@ -26,7 +26,7 @@ import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.Functi import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.TypeInfo import org.jetbrains.kotlin.psi.JetForExpression import org.jetbrains.kotlin.types.Variance -import org.jetbrains.kotlin.types.expressions.OperatorConventions +import org.jetbrains.kotlin.util.OperatorNameConventions object CreateHasNextFunctionActionFactory : CreateCallableMemberFromUsageFactory() { override fun getElementOfInterest(diagnostic: Diagnostic): JetForExpression? { @@ -38,6 +38,6 @@ object CreateHasNextFunctionActionFactory : CreateCallableMemberFromUsageFactory DiagnosticFactory.cast(diagnostic, Errors.HAS_NEXT_MISSING, Errors.HAS_NEXT_FUNCTION_NONE_APPLICABLE) val ownerType = TypeInfo(diagnosticWithParameters.a, Variance.IN_VARIANCE) val returnType = TypeInfo(element.platform.builtIns.booleanType, Variance.OUT_VARIANCE) - return FunctionInfo(OperatorConventions.HAS_NEXT.asString(), ownerType, returnType, isOperator = true) + return FunctionInfo(OperatorNameConventions.HAS_NEXT.asString(), ownerType, returnType, isOperator = true) } } diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateInvokeFunctionActionFactory.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateInvokeFunctionActionFactory.kt index c456a58e152..c91eb555365 100644 --- a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateInvokeFunctionActionFactory.kt +++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateInvokeFunctionActionFactory.kt @@ -25,7 +25,7 @@ import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.Parame import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.TypeInfo import org.jetbrains.kotlin.psi.JetCallExpression import org.jetbrains.kotlin.types.Variance -import org.jetbrains.kotlin.types.expressions.OperatorConventions +import org.jetbrains.kotlin.util.OperatorNameConventions object CreateInvokeFunctionActionFactory : CreateCallableMemberFromUsageFactory() { override fun getElementOfInterest(diagnostic: Diagnostic): JetCallExpression? { @@ -47,6 +47,6 @@ object CreateInvokeFunctionActionFactory : CreateCallableMemberFromUsageFactory< } val returnType = TypeInfo(element, Variance.OUT_VARIANCE) - return FunctionInfo(OperatorConventions.INVOKE.asString(), receiverType, returnType, parameterInfos = parameters, isOperator = true) + return FunctionInfo(OperatorNameConventions.INVOKE.asString(), receiverType, returnType, parameterInfos = parameters, isOperator = true) } } diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateIteratorFunctionActionFactory.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateIteratorFunctionActionFactory.kt index 96f76351a76..32c148730fd 100644 --- a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateIteratorFunctionActionFactory.kt +++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateIteratorFunctionActionFactory.kt @@ -30,7 +30,7 @@ import org.jetbrains.kotlin.psi.JetForExpression import org.jetbrains.kotlin.types.JetTypeImpl import org.jetbrains.kotlin.types.TypeProjectionImpl import org.jetbrains.kotlin.types.Variance -import org.jetbrains.kotlin.types.expressions.OperatorConventions +import org.jetbrains.kotlin.util.OperatorNameConventions import java.util.* object CreateIteratorFunctionActionFactory : CreateCallableMemberFromUsageFactory() { @@ -58,6 +58,6 @@ object CreateIteratorFunctionActionFactory : CreateCallableMemberFromUsageFactor returnJetTypeArguments, returnJetType.memberScope) val returnType = TypeInfo(newReturnJetType, Variance.OUT_VARIANCE) - return FunctionInfo(OperatorConventions.ITERATOR.asString(), iterableType, returnType, isOperator = true) + return FunctionInfo(OperatorNameConventions.ITERATOR.asString(), iterableType, returnType, isOperator = true) } } diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateNextFunctionActionFactory.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateNextFunctionActionFactory.kt index bafbedb3d9f..7b739368871 100644 --- a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateNextFunctionActionFactory.kt +++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateNextFunctionActionFactory.kt @@ -26,7 +26,7 @@ import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.TypeIn import org.jetbrains.kotlin.psi.JetExpression import org.jetbrains.kotlin.psi.JetForExpression import org.jetbrains.kotlin.types.Variance -import org.jetbrains.kotlin.types.expressions.OperatorConventions +import org.jetbrains.kotlin.util.OperatorNameConventions object CreateNextFunctionActionFactory : CreateCallableMemberFromUsageFactory() { override fun getElementOfInterest(diagnostic: Diagnostic): JetForExpression? { @@ -39,6 +39,6 @@ object CreateNextFunctionActionFactory : CreateCallableMemberFromUsageFactory { @@ -163,7 +163,7 @@ object NativeSetterCallCase : AnnotatedAsNativeXCallCase(PredefinedAnnotation.NA object InvokeIntrinsic : FunctionCallCase() { fun canApply(callInfo: FunctionCallInfo): Boolean { val callableDescriptor = callInfo.callableDescriptor - if (callableDescriptor.getName() != OperatorConventions.INVOKE) + if (callableDescriptor.getName() != OperatorNameConventions.INVOKE) return false val parameterCount = callableDescriptor.getValueParameters().size() val funDeclaration = callableDescriptor.getContainingDeclaration() diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/intrinsic/functions/factories/PrimitiveBinaryOperationFIF.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/intrinsic/functions/factories/PrimitiveBinaryOperationFIF.java index 39b5ee4cc9c..dfbe15190c5 100644 --- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/intrinsic/functions/factories/PrimitiveBinaryOperationFIF.java +++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/intrinsic/functions/factories/PrimitiveBinaryOperationFIF.java @@ -35,6 +35,7 @@ import org.jetbrains.kotlin.js.translate.utils.JsDescriptorUtils; import org.jetbrains.kotlin.lexer.JetToken; import org.jetbrains.kotlin.name.Name; import org.jetbrains.kotlin.types.expressions.OperatorConventions; +import org.jetbrains.kotlin.util.OperatorNameConventions; import java.util.List; @@ -143,7 +144,7 @@ public enum PrimitiveBinaryOperationFIF implements FunctionIntrinsicFactory { } - if (JsDescriptorUtils.isBuiltin(descriptor) && descriptor.getName().equals(OperatorConventions.COMPARE_TO)) { + if (JsDescriptorUtils.isBuiltin(descriptor) && descriptor.getName().equals(OperatorNameConventions.COMPARE_TO)) { return BUILTINS_COMPARE_TO_INTRINSIC; } diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/utils/JsAstUtils.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/utils/JsAstUtils.java index f1d15ee3c9d..19888a2b167 100644 --- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/utils/JsAstUtils.java +++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/utils/JsAstUtils.java @@ -23,6 +23,7 @@ import org.jetbrains.annotations.Nullable; import org.jetbrains.kotlin.js.translate.context.Namer; import org.jetbrains.kotlin.js.translate.context.TranslationContext; import org.jetbrains.kotlin.types.expressions.OperatorConventions; +import org.jetbrains.kotlin.util.OperatorNameConventions; import java.util.Arrays; import java.util.Collections; @@ -160,7 +161,7 @@ public final class JsAstUtils { @NotNull public static JsExpression compareTo(@NotNull JsExpression left, @NotNull JsExpression right) { - return invokeKotlinFunction(OperatorConventions.COMPARE_TO.getIdentifier(), left, right); + return invokeKotlinFunction(OperatorNameConventions.COMPARE_TO.getIdentifier(), left, right); } @NotNull diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/utils/JsDescriptorUtils.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/utils/JsDescriptorUtils.java index 366527ef31a..bfb5b1aa507 100644 --- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/utils/JsDescriptorUtils.java +++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/utils/JsDescriptorUtils.java @@ -32,7 +32,7 @@ import org.jetbrains.kotlin.resolve.DescriptorUtils; import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue; import org.jetbrains.kotlin.resolve.scopes.receivers.ThisReceiver; import org.jetbrains.kotlin.types.JetType; -import org.jetbrains.kotlin.types.expressions.OperatorConventions; +import org.jetbrains.kotlin.util.OperatorNameConventions; import java.util.Collection; import java.util.List; @@ -62,7 +62,7 @@ public final class JsDescriptorUtils { } public static boolean isCompareTo(@NotNull CallableDescriptor descriptor) { - return descriptor.getName().equals(OperatorConventions.COMPARE_TO); + return descriptor.getName().equals(OperatorNameConventions.COMPARE_TO); } @Nullable