From e4cd7cdbcf2269a612d571a34a82dbedcb93979b Mon Sep 17 00:00:00 2001 From: Alexander Udalov Date: Tue, 4 Aug 2020 12:24:18 +0200 Subject: [PATCH] IR: remove unused code, cleanup --- .../jetbrains/kotlin/backend/common/Utils.kt | 5 - .../common/descriptors/DescriptorUtils.kt | 34 +--- .../kotlin/backend/common/ir/IrInlineUtils.kt | 9 +- .../kotlin/backend/common/ir/IrUtils.kt | 15 +- .../backend/common/ir/descriptorBasedUtils.kt | 1 + .../lower/InlineClassDeclarationLowering.kt | 2 +- .../jetbrains/kotlin/ir/util/IrTypeUtils.kt | 18 +-- .../generators/SyntheticDescriptorsFactory.kt | 71 --------- .../kotlin/ir/descriptors/IrBuiltIns.kt | 10 +- .../IrSyntheticPropertyAccessorDescriptor.kt | 79 ---------- .../kotlin/ir/symbols/IrDelegatingSymbol.kt | 7 +- .../jetbrains/kotlin/ir/symbols/IrSymbol.kt | 146 +++--------------- .../ir/symbols/impl/IrPrivateSymbolBase.kt | 34 ++-- .../ir/symbols/impl/IrPublicSymbolBase.kt | 18 +-- .../jetbrains/kotlin/ir/types/IrTypeUtils.kt | 47 +----- .../kotlin/ir/types/impl/IrSimpleTypeImpl.kt | 5 +- .../kotlin/ir/types/irTypePredicates.kt | 12 -- .../kotlin/ir/util/AdditionalIrUtils.kt | 49 ++---- .../ir/util/DataClassMembersGenerator.kt | 10 +- .../kotlin/ir/util/IrSymbolVisitor.kt | 72 --------- .../org/jetbrains/kotlin/ir/util/IrUtils.kt | 84 +--------- .../jetbrains/kotlin/ir/util/KotlinUtils.kt | 18 --- .../serialization/LegacyDescriptorUtils.kt | 9 +- .../compiler/impl/KJvmReplCompleter.kt | 5 +- 24 files changed, 90 insertions(+), 670 deletions(-) delete mode 100644 compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/SyntheticDescriptorsFactory.kt delete mode 100644 compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/descriptors/IrSyntheticPropertyAccessorDescriptor.kt delete mode 100644 compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/IrSymbolVisitor.kt delete mode 100644 compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/KotlinUtils.kt diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/Utils.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/Utils.kt index d1b4903ce04..219d607b7a2 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/Utils.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/Utils.kt @@ -28,8 +28,3 @@ fun MutableList.push(element: E) = this.add(element) fun MutableList.pop() = this.removeAt(size - 1) fun MutableList.peek(): E? = if (size == 0) null else this[size - 1] - -fun T.onlyIf(condition: T.()->Boolean, then: (T)->Unit): T { - if (this.condition()) then(this) - return this -} diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/descriptors/DescriptorUtils.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/descriptors/DescriptorUtils.kt index a314109c26d..e0277ba4d35 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/descriptors/DescriptorUtils.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/descriptors/DescriptorUtils.kt @@ -16,25 +16,16 @@ package org.jetbrains.kotlin.backend.common.descriptors -import org.jetbrains.kotlin.builtins.functions.FunctionClassDescriptor -import org.jetbrains.kotlin.builtins.getFunctionalClassKind -import org.jetbrains.kotlin.descriptors.* -import org.jetbrains.kotlin.incremental.components.NoLookupLocation +import org.jetbrains.kotlin.descriptors.CallableDescriptor +import org.jetbrains.kotlin.descriptors.ConstructorDescriptor +import org.jetbrains.kotlin.descriptors.FunctionDescriptor +import org.jetbrains.kotlin.descriptors.ParameterDescriptor import org.jetbrains.kotlin.name.Name -import org.jetbrains.kotlin.types.KotlinType -import org.jetbrains.kotlin.types.TypeProjectionImpl -import org.jetbrains.kotlin.types.TypeSubstitutor -import org.jetbrains.kotlin.types.replace val String.synthesizedName: Name get() = Name.identifier(this.synthesizedString) val String.synthesizedString: String get() = "\$$this" -val DeclarationDescriptor.propertyIfAccessor: DeclarationDescriptor - get() = if (this is PropertyAccessorDescriptor) - this.correspondingProperty - else this - val CallableDescriptor.isSuspend: Boolean get() = this is FunctionDescriptor && isSuspend @@ -69,20 +60,3 @@ val CallableDescriptor.explicitParameters: List return result } - -// Used in Kotlin/Native -@Suppress("unused") -fun FunctionDescriptor.substitute(vararg types: KotlinType): FunctionDescriptor { - val typeSubstitutor = TypeSubstitutor.create( - typeParameters - .withIndex() - .associateBy({ it.value.typeConstructor }, { TypeProjectionImpl(types[it.index]) }) - ) - return substitute(typeSubstitutor)!! -} - -val KotlinType.isFunctionOrKFunctionType: Boolean - get() { - val kind = constructor.declarationDescriptor?.getFunctionalClassKind() - return kind == FunctionClassDescriptor.Kind.Function || kind == FunctionClassDescriptor.Kind.KFunction - } diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/ir/IrInlineUtils.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/ir/IrInlineUtils.kt index 4cc7343716c..5c75cd37c1b 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/ir/IrInlineUtils.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/ir/IrInlineUtils.kt @@ -6,15 +6,14 @@ package org.jetbrains.kotlin.backend.common.ir import org.jetbrains.kotlin.backend.common.lower.VariableRemapper -import org.jetbrains.kotlin.ir.ObsoleteDescriptorBasedAPI import org.jetbrains.kotlin.ir.IrStatement +import org.jetbrains.kotlin.ir.ObsoleteDescriptorBasedAPI import org.jetbrains.kotlin.ir.declarations.* import org.jetbrains.kotlin.ir.expressions.* import org.jetbrains.kotlin.ir.expressions.impl.IrReturnImpl import org.jetbrains.kotlin.ir.expressions.impl.IrReturnableBlockImpl import org.jetbrains.kotlin.ir.symbols.IrReturnTargetSymbol import org.jetbrains.kotlin.ir.symbols.impl.IrReturnableBlockSymbolImpl -import org.jetbrains.kotlin.ir.util.deepCopyWithSymbols import org.jetbrains.kotlin.ir.util.isVararg import org.jetbrains.kotlin.ir.util.statements @@ -45,12 +44,6 @@ private fun createParameterMapping(source: IrFunction, target: IrFunction): Map< return sourceParameters.zip(targetParameters).toMap() } -fun IrFunction.copyBodyTo(target: IrFunction): IrBody? = - copyBodyTo(target, createParameterMapping(this, target)) - -fun IrFunction.copyBodyTo(target: IrFunction, arguments: Map): IrBody? = - body?.deepCopyWithSymbols(target)?.move(this, target, target.symbol, arguments) - fun IrFunction.moveBodyTo(target: IrFunction): IrBody? = moveBodyTo(target, createParameterMapping(this, target)) diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/ir/IrUtils.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/ir/IrUtils.kt index 50d326fa6bd..038a54ba276 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/ir/IrUtils.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/ir/IrUtils.kt @@ -40,7 +40,7 @@ import java.io.StringWriter fun ir2string(ir: IrElement?): String = ir?.render() ?: "" -// NB: this function is used in native +@Suppress("unused") // Used in kotlin-native fun ir2stringWhole(ir: IrElement?): String { val strWriter = StringWriter() ir?.accept(DumpIrTreeVisitor(strWriter), "") @@ -107,15 +107,6 @@ fun IrReturnTarget.returnType(context: CommonBackendContext) = val IrClass.isFinalClass: Boolean get() = modality == Modality.FINAL && kind != ClassKind.ENUM_CLASS -// For an annotation, get the annotation class. -fun IrCall.getAnnotationClass(): IrClass { - val callable = symbol.owner - assert(callable is IrConstructor) { "Constructor call expected, got ${ir2string(this)}" } - val annotationClass = callable.parentAsClass - assert(annotationClass.isAnnotationClass) { "Annotation class expected, got ${ir2string(annotationClass)}" } - return annotationClass -} - val IrTypeParametersContainer.classIfConstructor get() = if (this is IrConstructor) parentAsClass else this @OptIn(ObsoleteDescriptorBasedAPI::class) @@ -348,10 +339,6 @@ fun IrDeclarationContainer.addChild(declaration: IrDeclaration) { declaration.setDeclarationsParent(this) } -fun IrDeclarationContainer.addChildren(declarations: List) { - declarations.forEach { this.addChild(it) } -} - fun T.setDeclarationsParent(parent: IrDeclarationParent): T { accept(SetDeclarationsParentVisitor, parent) return this diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/ir/descriptorBasedUtils.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/ir/descriptorBasedUtils.kt index ae0e2f28be0..1485ab523b7 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/ir/descriptorBasedUtils.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/ir/descriptorBasedUtils.kt @@ -15,6 +15,7 @@ val IrDeclaration.isExpect // The original isExpect represents what user has written. // This predicate means "there can possibly exist an 'actual' for the given declaration". // Shouldn't it be incorporated to descriptor -> ir declaration psi2ir translation phase? +@Suppress("unused") val IrDeclaration.isProperExpect: Boolean get() = this is IrClass && isExpect || this is IrFunction && isExpect || diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/InlineClassDeclarationLowering.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/InlineClassDeclarationLowering.kt index 0ccfdc2cf5e..b9838c6a8f7 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/InlineClassDeclarationLowering.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/InlineClassDeclarationLowering.kt @@ -242,7 +242,7 @@ class InlineClassLowering(val context: CommonBackendContext) { val klass = function.parentAsClass return when { !klass.isInline -> expression - function.isPrimary -> irConstructorCall(expression, function) + function.isPrimary -> irConstructorCall(expression, function.symbol) else -> irCall(expression, getOrCreateStaticMethod(function)) } } diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/ir/util/IrTypeUtils.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/ir/util/IrTypeUtils.kt index f6f47db0916..8e1e333acea 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/ir/util/IrTypeUtils.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/ir/util/IrTypeUtils.kt @@ -8,7 +8,10 @@ package org.jetbrains.kotlin.ir.util import org.jetbrains.kotlin.builtins.KotlinBuiltIns.FQ_NAMES import org.jetbrains.kotlin.builtins.UnsignedTypes import org.jetbrains.kotlin.descriptors.ClassKind -import org.jetbrains.kotlin.ir.declarations.* +import org.jetbrains.kotlin.ir.declarations.IrClass +import org.jetbrains.kotlin.ir.declarations.IrDeclarationWithName +import org.jetbrains.kotlin.ir.declarations.IrPackageFragment +import org.jetbrains.kotlin.ir.declarations.IrTypeParameter import org.jetbrains.kotlin.ir.symbols.IrClassSymbol import org.jetbrains.kotlin.ir.symbols.IrClassifierSymbol import org.jetbrains.kotlin.ir.symbols.IrTypeParameterSymbol @@ -18,7 +21,6 @@ import org.jetbrains.kotlin.ir.types.impl.makeTypeProjection import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.utils.DFS -import org.jetbrains.kotlin.ir.types.isNullable as irTreeTypeUtils_isNullable val kotlinPackageFqn = FqName.fromSegments(listOf("kotlin")) private val kotlinReflectionPackageFqn = kotlinPackageFqn.child(Name.identifier("reflect")) @@ -31,7 +33,6 @@ fun IrType.isKSuspendFunction(): Boolean = classifierOrNull?.isClassWithNamePref fun IrClassifierSymbol.isFunction(): Boolean = this.isClassWithNamePrefix("Function", kotlinPackageFqn) fun IrClassifierSymbol.isKFunction(): Boolean = this.isClassWithNamePrefix("KFunction", kotlinReflectionPackageFqn) -fun IrClassifierSymbol.isSuspendFunction(): Boolean = this.isClassWithNamePrefix("SuspendFunction", kotlinCoroutinesPackageFqn) fun IrClassifierSymbol.isKSuspendFunction(): Boolean = this.isClassWithNamePrefix("KSuspendFunction", kotlinReflectionPackageFqn) private fun IrClassifierSymbol.isClassWithNamePrefix(prefix: String, packageFqName: FqName): Boolean { @@ -56,19 +57,8 @@ fun IrType.isFunctionOrKFunction() = isFunction() || isKFunction() fun IrType.isSuspendFunctionOrKFunction() = isSuspendFunction() || isKSuspendFunction() - -@Deprecated( - "Use org.jetbrains.kotlin.ir.types.isNullable instead.", - ReplaceWith("this.isNullable()", "org.jetbrains.kotlin.ir.types.isNullable") -) -@Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE") -@kotlin.internal.LowPriorityInOverloadResolution -fun IrType.isNullable(): Boolean = this.irTreeTypeUtils_isNullable() - fun IrType.isThrowable(): Boolean = isTypeFromKotlinPackage { name -> name.asString() == "Throwable" } -fun IrType.isThrowableTypeOrSubtype(): Boolean = DFS.ifAny(listOf(this), IrType::superTypes, IrType::isThrowable) - fun IrType.isUnsigned(): Boolean = isTypeFromKotlinPackage { name -> UnsignedTypes.isShortNameOfUnsignedType(name) } private inline fun IrType.isTypeFromKotlinPackage(namePredicate: (Name) -> Boolean): Boolean { diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/SyntheticDescriptorsFactory.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/SyntheticDescriptorsFactory.kt deleted file mode 100644 index f94f437f28c..00000000000 --- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/SyntheticDescriptorsFactory.kt +++ /dev/null @@ -1,71 +0,0 @@ -/* - * Copyright 2010-2016 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.psi2ir.generators - -import org.jetbrains.kotlin.descriptors.ClassDescriptor -import org.jetbrains.kotlin.descriptors.PropertyDescriptor -import org.jetbrains.kotlin.descriptors.PropertyGetterDescriptor -import org.jetbrains.kotlin.descriptors.PropertySetterDescriptor -import org.jetbrains.kotlin.ir.descriptors.IrSyntheticPropertyAccessorDescriptor.Kind.MEMBER_PROPERTY -import org.jetbrains.kotlin.ir.descriptors.IrSyntheticPropertyAccessorDescriptor.Kind.STATIC_PROPERTY -import org.jetbrains.kotlin.ir.descriptors.IrSyntheticPropertyGetterDescriptorImpl -import org.jetbrains.kotlin.ir.descriptors.IrSyntheticPropertySetterDescriptorImpl -import java.lang.AssertionError -import java.util.* - - -class SyntheticDescriptorsFactory { - private val propertyGetters = HashMap() - - private fun generateGetter(property: PropertyDescriptor): PropertyGetterDescriptor { - return when { - isStaticPropertyInClass(property) -> - IrSyntheticPropertyGetterDescriptorImpl(property, STATIC_PROPERTY) - isPropertyInClass(property) -> - IrSyntheticPropertyGetterDescriptorImpl(property, MEMBER_PROPERTY) - else -> - throw AssertionError("Don't know how to create synthetic getter for $property") - } - } - - private val propertySetters = HashMap() - - private fun generateSetter(property: PropertyDescriptor): PropertySetterDescriptor { - return when { - isStaticPropertyInClass(property) -> - IrSyntheticPropertySetterDescriptorImpl(property, STATIC_PROPERTY) - isPropertyInClass(property) -> - IrSyntheticPropertySetterDescriptorImpl(property, MEMBER_PROPERTY) - else -> - throw AssertionError("Don't know how to create synthetic setter for $property") - } - } - - private fun isStaticPropertyInClass(propertyDescriptor: PropertyDescriptor): Boolean = - propertyDescriptor.containingDeclaration is ClassDescriptor && - propertyDescriptor.dispatchReceiverParameter == null && - propertyDescriptor.extensionReceiverParameter == null - - private fun isPropertyInClass(propertyDescriptor: PropertyDescriptor): Boolean = - propertyDescriptor.containingDeclaration is ClassDescriptor - - fun getOrCreatePropertyGetter(propertyDescriptor: PropertyDescriptor): PropertyGetterDescriptor = - propertyGetters.getOrPut(propertyDescriptor) { generateGetter(propertyDescriptor) } - - fun getOrCreatePropertySetter(propertyDescriptor: PropertyDescriptor): PropertySetterDescriptor = - propertySetters.getOrPut(propertyDescriptor) { generateSetter(propertyDescriptor) } -} diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/descriptors/IrBuiltIns.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/descriptors/IrBuiltIns.kt index f9ef541c48e..f41d1ec356c 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/descriptors/IrBuiltIns.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/descriptors/IrBuiltIns.kt @@ -80,7 +80,7 @@ class IrBuiltIns( val valueParameterSymbol = IrValueParameterSymbolImpl(valueParameterDescriptor) irFactory.createValueParameter( UNDEFINED_OFFSET, UNDEFINED_OFFSET, BUILTIN_OPERATOR, valueParameterSymbol, Name.identifier("arg$i"), i, - valueParameterType, null, false, false + valueParameterType, null, isCrossinline = false, isNoinline = false ).apply { parent = operator } @@ -120,7 +120,8 @@ class IrBuiltIns( valueParameterDescriptor = ValueParameterDescriptorImpl( this, null, 0, Annotations.EMPTY, Name.identifier("arg0"), valueKotlinType, - false, false, false, null, SourceElement.NO_SOURCE + declaresDefaultValue = false, isCrossinline = false, isNoinline = false, varargElementType = null, + source = SourceElement.NO_SOURCE ) returnKotlinType = typeParameterDescriptor.typeConstructor.makeNonNullType() @@ -184,7 +185,6 @@ class IrBuiltIns( associate { it.classifierOrFail to defineComparisonOperator(name, it) } val any = builtIns.anyType - val anyN = builtIns.nullableAnyType val anyType = any.toIrType() val anyClass = builtIns.any.toIrSymbol() val anyNType = anyType.withHasQuestionMark(true) @@ -226,7 +226,6 @@ class IrBuiltIns( val doubleClass = builtIns.double.toIrSymbol() val nothing = builtIns.nothingType - val nothingN = builtIns.nullableNothingType val nothingType = nothing.toIrType() val nothingClass = builtIns.nothing.toIrSymbol() val nothingNType = nothingType.withHasQuestionMark(true) @@ -321,9 +320,6 @@ class IrBuiltIns( fun function(n: Int): IrClassSymbol = functionFactory.functionN(n).symbol fun suspendFunction(n: Int): IrClassSymbol = functionFactory.suspendFunctionN(n).symbol - fun kFunction(n: Int): IrClassSymbol = functionFactory.kFunctionN(n).symbol - fun kSuspendFunction(n: Int): IrClassSymbol = functionFactory.kSuspendFunctionN(n).symbol - companion object { val KOTLIN_INTERNAL_IR_FQN = FqName("kotlin.internal.ir") val BUILTIN_OPERATOR = object : IrDeclarationOriginImpl("OPERATOR") {} diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/descriptors/IrSyntheticPropertyAccessorDescriptor.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/descriptors/IrSyntheticPropertyAccessorDescriptor.kt deleted file mode 100644 index 92736ee079e..00000000000 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/descriptors/IrSyntheticPropertyAccessorDescriptor.kt +++ /dev/null @@ -1,79 +0,0 @@ -/* - * Copyright 2010-2016 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.ir.descriptors - -import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor -import org.jetbrains.kotlin.descriptors.Modality -import org.jetbrains.kotlin.descriptors.PropertyAccessorDescriptor -import org.jetbrains.kotlin.descriptors.PropertyDescriptor -import org.jetbrains.kotlin.descriptors.annotations.Annotations -import org.jetbrains.kotlin.descriptors.impl.PropertyGetterDescriptorImpl -import org.jetbrains.kotlin.descriptors.impl.PropertySetterDescriptorImpl - - -interface IrSyntheticPropertyAccessorDescriptor : PropertyAccessorDescriptor { - enum class Kind { - STATIC_PROPERTY, - MEMBER_PROPERTY - } - - val kind: Kind -} - -interface IrSyntheticPropertyGetterDescriptor : IrSyntheticPropertyAccessorDescriptor - -interface IrSyntheticPropertySetterDescriptor : IrSyntheticPropertyAccessorDescriptor - -class IrSyntheticPropertyGetterDescriptorImpl( - correspondingProperty: PropertyDescriptor, - override val kind: IrSyntheticPropertyAccessorDescriptor.Kind -) : PropertyGetterDescriptorImpl( - correspondingProperty, - Annotations.EMPTY, - Modality.FINAL, - correspondingProperty.visibility, - true, // isDefault - false, // isExternal - false, // isInline - CallableMemberDescriptor.Kind.SYNTHESIZED, - null, - correspondingProperty.source -), IrSyntheticPropertyGetterDescriptor { - init { - initialize(correspondingProperty.type) - } -} - -class IrSyntheticPropertySetterDescriptorImpl( - correspondingProperty: PropertyDescriptor, - override val kind: IrSyntheticPropertyAccessorDescriptor.Kind -) : PropertySetterDescriptorImpl( - correspondingProperty, - Annotations.EMPTY, - Modality.FINAL, - correspondingProperty.visibility, - true, // isDefault - false, // isExternal - false, // isInline - CallableMemberDescriptor.Kind.SYNTHESIZED, - null, - correspondingProperty.source -), IrSyntheticPropertySetterDescriptor { - init { - initializeDefault() - } -} \ No newline at end of file diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/symbols/IrDelegatingSymbol.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/symbols/IrDelegatingSymbol.kt index db61989dd51..c1910aee720 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/symbols/IrDelegatingSymbol.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/symbols/IrDelegatingSymbol.kt @@ -1,3 +1,8 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + package org.jetbrains.kotlin.ir.symbols import org.jetbrains.kotlin.descriptors.* @@ -54,4 +59,4 @@ fun wrapInDelegatedSymbol(delegate: IrSymbol) = when(delegate) { is IrPropertySymbol -> IrDelegatingPropertySymbolImpl(delegate) is IrTypeAliasSymbol -> IrDelegatingTypeAliasSymbolImpl(delegate) else -> error("Unexpected symbol to delegate to: $delegate") -} \ No newline at end of file +} diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/symbols/IrSymbol.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/symbols/IrSymbol.kt index 3e89e179396..e8c814cec5f 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/symbols/IrSymbol.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/symbols/IrSymbol.kt @@ -19,10 +19,8 @@ package org.jetbrains.kotlin.ir.symbols import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.ir.ObsoleteDescriptorBasedAPI import org.jetbrains.kotlin.ir.declarations.* -import org.jetbrains.kotlin.ir.declarations.IrScript import org.jetbrains.kotlin.ir.expressions.IrReturnableBlock import org.jetbrains.kotlin.ir.util.IdSignature -import org.jetbrains.kotlin.ir.util.IrSymbolVisitor import org.jetbrains.kotlin.types.model.TypeConstructorMarker import org.jetbrains.kotlin.types.model.TypeParameterMarker @@ -37,8 +35,6 @@ interface IrSymbol { val signature: IdSignature val isPublicApi: Boolean - - fun accept(visitor: IrSymbolVisitor, data: D): R } interface IrBindableSymbol : IrSymbol { @@ -53,161 +49,59 @@ interface IrBindableSymbol : I interface IrPackageFragmentSymbol : IrSymbol { @ObsoleteDescriptorBasedAPI override val descriptor: PackageFragmentDescriptor - - override fun accept(visitor: IrSymbolVisitor, data: D): R = - visitor.visitPackageFragmentSymbol(this, data) } -interface IrFileSymbol : - IrPackageFragmentSymbol, IrBindableSymbol { +interface IrFileSymbol : IrPackageFragmentSymbol, IrBindableSymbol - override fun accept(visitor: IrSymbolVisitor, data: D): R = - visitor.visitFileSymbol(this, data) -} +interface IrExternalPackageFragmentSymbol : IrPackageFragmentSymbol, IrBindableSymbol -interface IrExternalPackageFragmentSymbol : - IrPackageFragmentSymbol, IrBindableSymbol { +interface IrAnonymousInitializerSymbol : IrBindableSymbol - override fun accept(visitor: IrSymbolVisitor, data: D): R = - visitor.visitExternalPackageFragmentSymbol(this, data) -} +interface IrEnumEntrySymbol : IrBindableSymbol -interface IrAnonymousInitializerSymbol : - IrBindableSymbol { - - override fun accept(visitor: IrSymbolVisitor, data: D): R = - visitor.visitAnonymousInitializerSymbol(this, data) -} - -interface IrEnumEntrySymbol : - IrBindableSymbol { - - override fun accept(visitor: IrSymbolVisitor, data: D): R = - visitor.visitEnumEntrySymbol(this, data) -} - -interface IrFieldSymbol : - IrBindableSymbol { - - override fun accept(visitor: IrSymbolVisitor, data: D): R = - visitor.visitFieldSymbol(this, data) -} - -interface IrClassifierSymbol : - IrSymbol, TypeConstructorMarker { +interface IrFieldSymbol : IrBindableSymbol +interface IrClassifierSymbol : IrSymbol, TypeConstructorMarker { @ObsoleteDescriptorBasedAPI override val descriptor: ClassifierDescriptor - - override fun accept(visitor: IrSymbolVisitor, data: D): R = - visitor.visitClassifierSymbol(this, data) } -interface IrClassSymbol : - IrClassifierSymbol, IrBindableSymbol { +interface IrClassSymbol : IrClassifierSymbol, IrBindableSymbol - override fun accept(visitor: IrSymbolVisitor, data: D): R = - visitor.visitClassSymbol(this, data) -} +interface IrScriptSymbol : IrSymbol, IrBindableSymbol -interface IrScriptSymbol : - IrSymbol, IrBindableSymbol { - - override fun accept(visitor: IrSymbolVisitor, data: D): R = - visitor.visitSymbol(this, data) -} - -interface IrTypeParameterSymbol : - IrClassifierSymbol, IrBindableSymbol, TypeParameterMarker { - - override fun accept(visitor: IrSymbolVisitor, data: D): R = - visitor.visitTypeParameterSymbol(this, data) -} - -interface IrValueSymbol : - IrSymbol { +interface IrTypeParameterSymbol : IrClassifierSymbol, IrBindableSymbol, TypeParameterMarker +interface IrValueSymbol : IrSymbol { @ObsoleteDescriptorBasedAPI override val descriptor: ValueDescriptor override val owner: IrValueDeclaration - - override fun accept(visitor: IrSymbolVisitor, data: D): R = - visitor.visitValueSymbol(this, data) } -interface IrValueParameterSymbol : - IrValueSymbol, IrBindableSymbol { +interface IrValueParameterSymbol : IrValueSymbol, IrBindableSymbol - override fun accept(visitor: IrSymbolVisitor, data: D): R = - visitor.visitValueParameterSymbol(this, data) -} - -interface IrVariableSymbol : - IrValueSymbol, IrBindableSymbol { - - override fun accept(visitor: IrSymbolVisitor, data: D): R = - visitor.visitVariableSymbol(this, data) -} - -interface IrReturnTargetSymbol : - IrSymbol { +interface IrVariableSymbol : IrValueSymbol, IrBindableSymbol +interface IrReturnTargetSymbol : IrSymbol { @ObsoleteDescriptorBasedAPI override val descriptor: FunctionDescriptor override val owner: IrReturnTarget - - override fun accept(visitor: IrSymbolVisitor, data: D): R = - visitor.visitReturnTargetSymbol(this, data) } -interface IrFunctionSymbol : - IrReturnTargetSymbol { - +interface IrFunctionSymbol : IrReturnTargetSymbol { override val owner: IrFunction - - override fun accept(visitor: IrSymbolVisitor, data: D): R = - visitor.visitFunctionSymbol(this, data) } -interface IrConstructorSymbol : - IrFunctionSymbol, IrBindableSymbol { +interface IrConstructorSymbol : IrFunctionSymbol, IrBindableSymbol - override fun accept(visitor: IrSymbolVisitor, data: D): R = - visitor.visitConstructorSymbol(this, data) -} -interface IrSimpleFunctionSymbol : - IrFunctionSymbol, IrBindableSymbol { +interface IrSimpleFunctionSymbol : IrFunctionSymbol, IrBindableSymbol - override fun accept(visitor: IrSymbolVisitor, data: D): R = - visitor.visitSimpleFunctionSymbol(this, data) -} +interface IrReturnableBlockSymbol : IrReturnTargetSymbol, IrBindableSymbol -interface IrReturnableBlockSymbol : - IrReturnTargetSymbol, IrBindableSymbol { +interface IrPropertySymbol : IrBindableSymbol - override fun accept(visitor: IrSymbolVisitor, data: D): R = - visitor.visitReturnableBlockSymbol(this, data) -} +interface IrLocalDelegatedPropertySymbol : IrBindableSymbol -interface IrPropertySymbol : - IrBindableSymbol { - - override fun accept(visitor: IrSymbolVisitor, data: D): R = - visitor.visitPropertySymbol(this, data) -} - -interface IrLocalDelegatedPropertySymbol : - IrBindableSymbol { - - override fun accept(visitor: IrSymbolVisitor, data: D): R = - visitor.visitLocalDelegatedPropertySymbol(this, data) -} - -interface IrTypeAliasSymbol : - IrBindableSymbol { - - override fun accept(visitor: IrSymbolVisitor, data: D): R = - visitor.visitTypeAliasSymbol(this, data) -} \ No newline at end of file +interface IrTypeAliasSymbol : IrBindableSymbol diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/symbols/impl/IrPrivateSymbolBase.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/symbols/impl/IrPrivateSymbolBase.kt index 652bc7ec311..75cae5a451d 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/symbols/impl/IrPrivateSymbolBase.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/symbols/impl/IrPrivateSymbolBase.kt @@ -19,7 +19,7 @@ package org.jetbrains.kotlin.ir.symbols.impl import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.ir.ObsoleteDescriptorBasedAPI import org.jetbrains.kotlin.ir.declarations.* -import org.jetbrains.kotlin.ir.descriptors.* +import org.jetbrains.kotlin.ir.descriptors.WrappedDeclarationDescriptor import org.jetbrains.kotlin.ir.expressions.IrReturnableBlock import org.jetbrains.kotlin.ir.symbols.* import org.jetbrains.kotlin.ir.util.IdSignature @@ -90,48 +90,40 @@ class IrExternalPackageFragmentSymbolImpl(descriptor: PackageFragmentDescriptor) class IrAnonymousInitializerSymbolImpl(descriptor: ClassDescriptor) : IrBindableSymbolBase(descriptor), IrAnonymousInitializerSymbol { - constructor(irClassSymbol: IrClassSymbol) : this(irClassSymbol.descriptor) {} + constructor(irClassSymbol: IrClassSymbol) : this(irClassSymbol.descriptor) } class IrClassSymbolImpl(descriptor: ClassDescriptor) : IrBindableSymbolBase(descriptor), - IrClassSymbol { -} + IrClassSymbol class IrEnumEntrySymbolImpl(descriptor: ClassDescriptor) : IrBindableSymbolBase(descriptor), - IrEnumEntrySymbol { -} + IrEnumEntrySymbol class IrFieldSymbolImpl(descriptor: PropertyDescriptor) : IrBindableSymbolBase(descriptor), - IrFieldSymbol { -} + IrFieldSymbol class IrTypeParameterSymbolImpl(descriptor: TypeParameterDescriptor) : IrBindableSymbolBase(descriptor), - IrTypeParameterSymbol { -} + IrTypeParameterSymbol class IrValueParameterSymbolImpl(descriptor: ParameterDescriptor) : IrBindableSymbolBase(descriptor), - IrValueParameterSymbol { -} + IrValueParameterSymbol class IrVariableSymbolImpl(descriptor: VariableDescriptor) : IrBindableSymbolBase(descriptor), - IrVariableSymbol { -} + IrVariableSymbol class IrSimpleFunctionSymbolImpl(descriptor: FunctionDescriptor) : IrBindableSymbolBase(descriptor), - IrSimpleFunctionSymbol { -} + IrSimpleFunctionSymbol class IrConstructorSymbolImpl(descriptor: ClassConstructorDescriptor) : IrBindableSymbolBase(descriptor), - IrConstructorSymbol { -} + IrConstructorSymbol class IrReturnableBlockSymbolImpl(descriptor: FunctionDescriptor) : IrBindableSymbolBase(descriptor), @@ -139,8 +131,7 @@ class IrReturnableBlockSymbolImpl(descriptor: FunctionDescriptor) : class IrPropertySymbolImpl(descriptor: PropertyDescriptor) : IrBindableSymbolBase(descriptor), - IrPropertySymbol { -} + IrPropertySymbol class IrLocalDelegatedPropertySymbolImpl(descriptor: VariableDescriptorWithAccessors) : IrBindableSymbolBase(descriptor), @@ -148,8 +139,7 @@ class IrLocalDelegatedPropertySymbolImpl(descriptor: VariableDescriptorWithAcces class IrTypeAliasSymbolImpl(descriptor: TypeAliasDescriptor) : IrBindableSymbolBase(descriptor), - IrTypeAliasSymbol { -} + IrTypeAliasSymbol class IrScriptSymbolImpl(descriptor: ScriptDescriptor) : IrScriptSymbol, IrBindableSymbolBase(descriptor) diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/symbols/impl/IrPublicSymbolBase.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/symbols/impl/IrPublicSymbolBase.kt index c5a18c664f0..8113ad4db88 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/symbols/impl/IrPublicSymbolBase.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/symbols/impl/IrPublicSymbolBase.kt @@ -60,30 +60,24 @@ abstract class IrBindablePublicSymbolBase(descriptor, sig), - IrClassSymbol { -} + IrClassSymbol class IrEnumEntryPublicSymbolImpl(descriptor: ClassDescriptor, sig: IdSignature) : IrBindablePublicSymbolBase(descriptor, sig), - IrEnumEntrySymbol { -} + IrEnumEntrySymbol class IrSimpleFunctionPublicSymbolImpl(descriptor: FunctionDescriptor, sig: IdSignature) : IrBindablePublicSymbolBase(descriptor, sig), - IrSimpleFunctionSymbol { -} + IrSimpleFunctionSymbol class IrConstructorPublicSymbolImpl(descriptor: ClassConstructorDescriptor, sig: IdSignature) : IrBindablePublicSymbolBase(descriptor, sig), - IrConstructorSymbol { -} + IrConstructorSymbol class IrPropertyPublicSymbolImpl(descriptor: PropertyDescriptor, sig: IdSignature) : IrBindablePublicSymbolBase(descriptor, sig), - IrPropertySymbol { -} + IrPropertySymbol class IrTypeAliasPublicSymbolImpl(descriptor: TypeAliasDescriptor, sig: IdSignature) : IrBindablePublicSymbolBase(descriptor, sig), - IrTypeAliasSymbol { -} + IrTypeAliasSymbol diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/IrTypeUtils.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/IrTypeUtils.kt index 626d90bb17b..8ba04f6d589 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/IrTypeUtils.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/IrTypeUtils.kt @@ -12,16 +12,13 @@ import org.jetbrains.kotlin.ir.symbols.IrClassSymbol import org.jetbrains.kotlin.ir.symbols.IrClassifierSymbol import org.jetbrains.kotlin.ir.symbols.IrTypeParameterSymbol import org.jetbrains.kotlin.ir.util.fqNameWhenAvailable -import org.jetbrains.kotlin.ir.util.render -import org.jetbrains.kotlin.resolve.calls.NewCommonSuperTypeCalculator import org.jetbrains.kotlin.types.AbstractTypeChecker import org.jetbrains.kotlin.types.AbstractTypeCheckerContext -import org.jetbrains.kotlin.utils.DFS -fun IrClassifierSymbol.superTypes() = when (this) { +fun IrClassifierSymbol.superTypes(): List = when (this) { is IrClassSymbol -> owner.superTypes is IrTypeParameterSymbol -> owner.superTypes - else -> emptyList() + else -> emptyList() } fun IrClassifierSymbol.isSubtypeOfClass(superClass: IrClassSymbol): Boolean { @@ -34,50 +31,10 @@ fun IrType.isSubtypeOfClass(superClass: IrClassSymbol): Boolean { return classifier.isSubtypeOfClass(superClass) } -fun Collection.commonSuperclass(): IrClassifierSymbol { - var superClassifiers: MutableSet? = null - - require(isNotEmpty()) - - val order = fold(emptyList()) { _, classifierSymbol -> - val visited = mutableSetOf() - DFS.topologicalOrder( - listOf(classifierSymbol), { it.superTypes().map { s -> (s as IrSimpleType).classifier } }, - DFS.VisitedWithSet(visited) - ).also { - if (superClassifiers == null) { - superClassifiers = visited - } else { - superClassifiers!!.apply { - retainAll { c -> visited.any { v -> FqNameEqualityChecker.areEqual(c, v) } } - } - } - } - } - - requireNotNull(superClassifiers) - - return order.firstOrNull { o -> superClassifiers!!.any { s -> FqNameEqualityChecker.areEqual(o, s) } } - ?: error( - "No common superType found for non-empty set of classifiers: ${joinToString( - prefix = "[", - postfix = "]" - ) { it.owner.render() }}" - ) -} - fun IrType.isSubtypeOf(superType: IrType, irBuiltIns: IrBuiltIns): Boolean { return AbstractTypeChecker.isSubtypeOf(IrTypeCheckerContext(irBuiltIns) as AbstractTypeCheckerContext, this, superType) } -// no searchable usages -// delete or FIXME: implement TypeConstructorMarker.isError and TypeConstructorMarker.toErrorType in IrTypeSystemContext -fun Collection.commonSupertype(irBuiltIns: IrBuiltIns): IrType { - return NewCommonSuperTypeCalculator.run { - IrTypeCheckerContext(irBuiltIns).commonSuperType(map { it }) as IrType - } -} - fun IrType.isNullable(): Boolean = when (this) { is IrSimpleType -> when (val classifier = classifier) { diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/impl/IrSimpleTypeImpl.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/impl/IrSimpleTypeImpl.kt index 4543f28cfa4..ba666ea3f9d 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/impl/IrSimpleTypeImpl.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/impl/IrSimpleTypeImpl.kt @@ -80,9 +80,6 @@ fun IrSimpleTypeBuilder.buildTypeProjection() = inline fun IrSimpleType.buildSimpleType(b: IrSimpleTypeBuilder.() -> Unit): IrSimpleType = toBuilder().apply(b).buildSimpleType() -inline fun IrSimpleType.buildTypeProjection(b: IrSimpleTypeBuilder.() -> Unit): IrTypeProjection = - toBuilder().apply(b).buildTypeProjection() - class IrTypeProjectionImpl internal constructor( override val type: IrType, override val variance: Variance @@ -108,4 +105,4 @@ fun makeTypeIntersection(types: List): IrType = with(types.map { makeTypeProjection(it, Variance.INVARIANT).type }.distinct()) { if (size == 1) return single() else firstOrNull { !(it.isAny() || it.isNullableAny()) } ?: first { it.isAny() } - } \ No newline at end of file + } diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/irTypePredicates.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/irTypePredicates.kt index 10388ceb05b..92b2e0a37ee 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/irTypePredicates.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/irTypePredicates.kt @@ -6,14 +6,12 @@ package org.jetbrains.kotlin.ir.types import org.jetbrains.kotlin.builtins.KotlinBuiltIns -import org.jetbrains.kotlin.descriptors.ClassDescriptor import org.jetbrains.kotlin.ir.declarations.IrClass import org.jetbrains.kotlin.ir.symbols.IrClassSymbol import org.jetbrains.kotlin.ir.symbols.IrClassifierSymbol import org.jetbrains.kotlin.ir.util.fqNameWhenAvailable import org.jetbrains.kotlin.name.FqNameUnsafe import org.jetbrains.kotlin.resolve.DescriptorUtils -import org.jetbrains.kotlin.resolve.DescriptorUtils.getFqName private fun IrType.isNotNullClassType(fqName: FqNameUnsafe) = isClassType(fqName, hasQuestionMark = false) private fun IrType.isNullableClassType(fqName: FqNameUnsafe) = isClassType(fqName, hasQuestionMark = true) @@ -35,9 +33,6 @@ private fun classFqNameEquals(symbol: IrClassSymbol, fqName: FqNameUnsafe): Bool private fun classFqNameEquals(declaration: IrClass, fqName: FqNameUnsafe): Boolean = declaration.name == fqName.shortName() && fqName == declaration.fqNameWhenAvailable?.toUnsafe() -private fun classFqNameEquals(descriptor: ClassDescriptor, fqName: FqNameUnsafe): Boolean = - descriptor.name == fqName.shortName() && fqName == getFqName(descriptor) - fun IrType.isAny(): Boolean = isNotNullClassType(KotlinBuiltIns.FQ_NAMES.any) fun IrType.isNullableAny(): Boolean = isNullableClassType(KotlinBuiltIns.FQ_NAMES.any) @@ -56,8 +51,6 @@ fun IrType.isNullablePrimitiveType(): Boolean = KotlinBuiltIns.FQ_NAMES.fqNameTo fun IrType.isMarkedNullable() = (this as? IrSimpleType)?.hasQuestionMark ?: false fun IrType.isUnit() = isNotNullClassType(KotlinBuiltIns.FQ_NAMES.unit) -fun IrType.isNullableUnit() = isNullableClassType(KotlinBuiltIns.FQ_NAMES.unit) -fun IrType.isUnitOrNullableUnit() = this.isUnit() || this.isNullableUnit() fun IrType.isBoolean(): Boolean = isNotNullClassType(KotlinBuiltIns.FQ_NAMES._boolean) fun IrType.isChar(): Boolean = isNotNullClassType(KotlinBuiltIns.FQ_NAMES._char) @@ -87,10 +80,5 @@ fun IrType.isLongArray(): Boolean = isNotNullClassType(FqNameUnsafe("kotlin.Long fun IrType.isFloatArray(): Boolean = isNotNullClassType(FqNameUnsafe("kotlin.FloatArray")) fun IrType.isDoubleArray(): Boolean = isNotNullClassType(FqNameUnsafe("kotlin.DoubleArray")) -fun IrType.isNullableBoolean(): Boolean = isNullableClassType(KotlinBuiltIns.FQ_NAMES._boolean) -fun IrType.isNullableLong(): Boolean = isNullableClassType(KotlinBuiltIns.FQ_NAMES._long) -fun IrType.isNullableChar(): Boolean = isNullableClassType(KotlinBuiltIns.FQ_NAMES._char) - fun IrType.isKotlinResult(): Boolean = isNotNullClassType(DescriptorUtils.RESULT_FQ_NAME.toUnsafe()) -fun IrType.isContinuation(): Boolean = isNotNullClassType(DescriptorUtils.CONTINUATION_INTERFACE_FQ_NAME_RELEASE.toUnsafe()) fun IrType.isNullableContinuation(): Boolean = isNullableClassType(DescriptorUtils.CONTINUATION_INTERFACE_FQ_NAME_RELEASE.toUnsafe()) diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/AdditionalIrUtils.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/AdditionalIrUtils.kt index ce37b41ef65..2f442a34242 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/AdditionalIrUtils.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/AdditionalIrUtils.kt @@ -5,7 +5,9 @@ package org.jetbrains.kotlin.ir.util +import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor import org.jetbrains.kotlin.descriptors.Visibilities +import org.jetbrains.kotlin.incremental.components.NoLookupLocation import org.jetbrains.kotlin.ir.* import org.jetbrains.kotlin.ir.declarations.* import org.jetbrains.kotlin.ir.expressions.IrConstructorCall @@ -16,12 +18,11 @@ import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.name.SpecialNames import org.jetbrains.kotlin.resolve.descriptorUtil.module +import org.jetbrains.kotlin.resolve.scopes.MemberScope import java.io.File val IrConstructor.constructedClass get() = this.parent as IrClass -val T.original get() = this - val IrDeclarationParent.fqNameForIrSerialization: FqName get() = when (this) { is IrPackageFragment -> this.fqName @@ -29,14 +30,6 @@ val IrDeclarationParent.fqNameForIrSerialization: FqName else -> error(this) } -@Deprecated( - "Use fqNameForIrSerialization instead.", - ReplaceWith("fqNameForIrSerialization", "org.jetbrains.kotlin.ir.util.fqNameForIrSerialization"), - DeprecationLevel.ERROR -) -val IrDeclarationParent.fqNameSafe: FqName - get() = fqNameForIrSerialization - val IrClass.classId: ClassId? get() = when (val parent = this.parent) { is IrClass -> parent.classId?.createNestedClassId(this.name) @@ -50,13 +43,6 @@ val IrDeclaration.nameForIrSerialization: Name is IrConstructor -> SPECIAL_INIT_NAME else -> error(this) } -@Deprecated( - "Use nameForIrSerialization instead.", - ReplaceWith("nameForIrSerialization", "org.jetbrains.kotlin.ir.util.nameForIrSerialization"), - DeprecationLevel.ERROR -) -val IrDeclaration.name: Name - get() = nameForIrSerialization private val SPECIAL_INIT_NAME = Name.special("") @@ -114,17 +100,6 @@ val IrDeclaration.isPropertyField get() = val IrDeclaration.isTopLevelDeclaration get() = parent !is IrDeclaration && !this.isPropertyAccessor && !this.isPropertyField -fun IrDeclaration.findTopLevelDeclaration(): IrDeclaration = when { - this.isTopLevelDeclaration -> - this - this.isPropertyAccessor -> - (this as IrSimpleFunction).correspondingPropertySymbol!!.owner.findTopLevelDeclaration() - this.isPropertyField -> - (this as IrField).correspondingPropertySymbol!!.owner.findTopLevelDeclaration() - else -> - (this.parent as IrDeclaration).findTopLevelDeclaration() -} - val IrDeclaration.isAnonymousObject get() = this is IrClass && name == SpecialNames.NO_NAME_PROVIDED val IrDeclaration.isLocal: Boolean @@ -173,10 +148,10 @@ val SourceManager.FileEntry.lineStartOffsets if (it.exists() && it.isFile) it.lineStartOffsets else IntArray(0) } -class NaiveSourceBasedFileEntryImpl(override val name: String, val lineStartOffsets: IntArray = IntArray(0)) : SourceManager.FileEntry { - - //-------------------------------------------------------------------------// - +class NaiveSourceBasedFileEntryImpl( + override val name: String, + private val lineStartOffsets: IntArray = intArrayOf() +) : SourceManager.FileEntry { override fun getLineNumber(offset: Int): Int { assert(offset != UNDEFINED_OFFSET) if (offset == SYNTHETIC_OFFSET) return 0 @@ -184,8 +159,6 @@ class NaiveSourceBasedFileEntryImpl(override val name: String, val lineStartOffs return if (index >= 0) index else -index - 2 } - //-------------------------------------------------------------------------// - override fun getColumnNumber(offset: Int): Int { assert(offset != UNDEFINED_OFFSET) if (offset == SYNTHETIC_OFFSET) return 0 @@ -193,16 +166,11 @@ class NaiveSourceBasedFileEntryImpl(override val name: String, val lineStartOffs return offset - lineStartOffsets[lineNumber] } - //-------------------------------------------------------------------------// - override val maxOffset: Int - //get() = TODO("not implemented") get() = UNDEFINED_OFFSET override fun getSourceRangeInfo(beginOffset: Int, endOffset: Int): SourceRangeInfo { - //TODO("not implemented") return SourceRangeInfo(name, beginOffset, -1, -1, endOffset, -1, -1) - } } @@ -231,3 +199,6 @@ fun IrClass.getPropertySetter(name: String): IrSimpleFunctionSymbol? = fun IrClassSymbol.getSimpleFunction(name: String): IrSimpleFunctionSymbol? = owner.getSimpleFunction(name) fun IrClassSymbol.getPropertyGetter(name: String): IrSimpleFunctionSymbol? = owner.getPropertyGetter(name) fun IrClassSymbol.getPropertySetter(name: String): IrSimpleFunctionSymbol? = owner.getPropertySetter(name) + +inline fun MemberScope.findFirstFunction(name: String, predicate: (CallableMemberDescriptor) -> Boolean) = + getContributedFunctions(Name.identifier(name), NoLookupLocation.FROM_BACKEND).first(predicate) diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DataClassMembersGenerator.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DataClassMembersGenerator.kt index 758a887cb77..ab46b792271 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DataClassMembersGenerator.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DataClassMembersGenerator.kt @@ -129,12 +129,14 @@ abstract class DataClassMembersGenerator( private val intType = context.builtIns.intType private val intTimesSymbol: IrSimpleFunctionSymbol = - intClass.findFirstFunction("times") { KotlinTypeChecker.DEFAULT.equalTypes(it.valueParameters[0].type, intType) } - .let { symbolTable.referenceSimpleFunction(it) } + intClass.unsubstitutedMemberScope.findFirstFunction("times") { + KotlinTypeChecker.DEFAULT.equalTypes(it.valueParameters[0].type, intType) + }.let { symbolTable.referenceSimpleFunction(it) } private val intPlusSymbol: IrSimpleFunctionSymbol = - intClass.findFirstFunction("plus") { KotlinTypeChecker.DEFAULT.equalTypes(it.valueParameters[0].type, intType) } - .let { symbolTable.referenceSimpleFunction(it) } + intClass.unsubstitutedMemberScope.findFirstFunction("plus") { + KotlinTypeChecker.DEFAULT.equalTypes(it.valueParameters[0].type, intType) + }.let { symbolTable.referenceSimpleFunction(it) } fun generateHashCodeMethodBody(properties: List) { val irIntType = context.irBuiltIns.intType diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/IrSymbolVisitor.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/IrSymbolVisitor.kt deleted file mode 100644 index de725929fbb..00000000000 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/IrSymbolVisitor.kt +++ /dev/null @@ -1,72 +0,0 @@ -/* - * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors. - * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. - */ - -package org.jetbrains.kotlin.ir.util - -import org.jetbrains.kotlin.ir.symbols.* - -interface IrSymbolVisitor { - fun visitSymbol(symbol: IrSymbol, data: D): R - - fun visitPackageFragmentSymbol(symbol: IrPackageFragmentSymbol, data: D) = - visitSymbol(symbol, data) - - fun visitFileSymbol(symbol: IrFileSymbol, data: D) = - visitPackageFragmentSymbol(symbol, data) - - fun visitExternalPackageFragmentSymbol(symbol: IrExternalPackageFragmentSymbol, data: D) = - visitPackageFragmentSymbol(symbol, data) - - fun visitClassifierSymbol(symbol: IrClassifierSymbol, data: D) = - visitSymbol(symbol, data) - - fun visitClassSymbol(symbol: IrClassSymbol, data: D) = - visitClassifierSymbol(symbol, data) - - fun visitTypeParameterSymbol(symbol: IrTypeParameterSymbol, data: D) = - visitClassifierSymbol(symbol, data) - - fun visitValueSymbol(symbol: IrValueSymbol, data: D) = - visitSymbol(symbol, data) - - fun visitVariableSymbol(symbol: IrVariableSymbol, data: D) = - visitValueSymbol(symbol, data) - - fun visitValueParameterSymbol(symbol: IrValueParameterSymbol, data: D) = - visitValueSymbol(symbol, data) - - fun visitReturnTargetSymbol(symbol: IrReturnTargetSymbol, data: D) = - visitSymbol(symbol, data) - - fun visitFunctionSymbol(symbol: IrFunctionSymbol, data: D) = - visitReturnTargetSymbol(symbol, data) - - fun visitSimpleFunctionSymbol(symbol: IrSimpleFunctionSymbol, data: D) = - visitFunctionSymbol(symbol, data) - - fun visitConstructorSymbol(symbol: IrConstructorSymbol, data: D) = - visitFunctionSymbol(symbol, data) - - fun visitReturnableBlockSymbol(symbol: IrReturnableBlockSymbol, data: D) = - visitReturnTargetSymbol(symbol, data) - - fun visitAnonymousInitializerSymbol(symbol: IrAnonymousInitializerSymbol, data: D) = - visitSymbol(symbol, data) - - fun visitEnumEntrySymbol(symbol: IrEnumEntrySymbol, data: D) = - visitSymbol(symbol, data) - - fun visitFieldSymbol(symbol: IrFieldSymbol, data: D) = - visitSymbol(symbol, data) - - fun visitPropertySymbol(symbol: IrPropertySymbol, data: D) = - visitSymbol(symbol, data) - - fun visitLocalDelegatedPropertySymbol(symbol: IrLocalDelegatedPropertySymbol, data: D) = - visitSymbol(symbol, data) - - fun visitTypeAliasSymbol(symbol: IrTypeAliasSymbol, data: D) = - visitSymbol(symbol, data) -} \ No newline at end of file diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/IrUtils.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/IrUtils.kt index a25faf9fb8f..474af2cc643 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/IrUtils.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/IrUtils.kt @@ -6,7 +6,6 @@ package org.jetbrains.kotlin.ir.util import org.jetbrains.kotlin.descriptors.* -import org.jetbrains.kotlin.descriptors.impl.DeclarationDescriptorVisitorEmptyBodies import org.jetbrains.kotlin.ir.IrElement import org.jetbrains.kotlin.ir.IrStatement import org.jetbrains.kotlin.ir.ObsoleteDescriptorBasedAPI @@ -20,11 +19,6 @@ import org.jetbrains.kotlin.ir.symbols.* import org.jetbrains.kotlin.ir.types.* import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.SpecialNames -import org.jetbrains.kotlin.psi.psiUtil.endOffset -import org.jetbrains.kotlin.psi.psiUtil.startOffset -import org.jetbrains.kotlin.resolve.DescriptorUtils -import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe -import org.jetbrains.kotlin.resolve.source.PsiSourceElement import org.jetbrains.kotlin.types.KotlinType import org.jetbrains.kotlin.types.checker.KotlinTypeChecker import org.jetbrains.kotlin.utils.DFS @@ -64,6 +58,7 @@ fun IrMemberAccessExpression<*>.getArguments(): List> { val res = mutableListOf>() val irFunction = symbol.owner @@ -149,6 +144,7 @@ fun IrMemberAccessExpression<*>.addArguments(args: Map.addArguments(args: List>) = this.addArguments(args.toMap()) @@ -162,14 +158,9 @@ fun IrExpression.isIntegerConst(value: Int) = this is IrConst<*> && this.kind == @OptIn(ObsoleteDescriptorBasedAPI::class) fun IrExpression.coerceToUnit(builtins: IrBuiltIns): IrExpression { - val valueType = getKotlinType(this) - return coerceToUnitIfNeeded(valueType, builtins) + return coerceToUnitIfNeeded(type.toKotlinType(), builtins) } -@ObsoleteDescriptorBasedAPI -private fun getKotlinType(irExpression: IrExpression) = - irExpression.type.toKotlinType() - @ObsoleteDescriptorBasedAPI fun IrExpression.coerceToUnitIfNeeded(valueType: KotlinType, irBuiltIns: IrBuiltIns): IrExpression { return if (KotlinTypeChecker.DEFAULT.isSubtypeOf(valueType, irBuiltIns.unitType.toKotlinType())) @@ -201,9 +192,6 @@ fun IrExpression.coerceToUnitIfNeeded(valueType: IrType, irBuiltIns: IrBuiltIns) fun IrMemberAccessExpression<*>.usesDefaultArguments(): Boolean = (symbol.descriptor as CallableDescriptor).valueParameters.any { this.getValueArgument(it) == null } -val DeclarationDescriptorWithSource.startOffset: Int? get() = (this.source as? PsiSourceElement)?.psi?.startOffset -val DeclarationDescriptorWithSource.endOffset: Int? get() = (this.source as? PsiSourceElement)?.psi?.endOffset - val IrClass.functions: Sequence get() = declarations.asSequence().filterIsInstance() @@ -297,10 +285,9 @@ fun IrClass.isLocalClass(): Boolean { tailrec fun IrElement.getPackageFragment(): IrPackageFragment? { if (this is IrPackageFragment) return this - val vParent = (this as? IrDeclaration)?.parent - return when (vParent) { - is IrPackageFragment -> vParent - else -> vParent?.getPackageFragment() + return when (val parent = (this as? IrDeclaration)?.parent) { + is IrPackageFragment -> parent + else -> parent?.getPackageFragment() } } @@ -366,22 +353,12 @@ fun IrFunction.isExternalOrInheritedFromExternal(): Boolean { inline fun IrDeclarationContainer.findDeclaration(predicate: (T) -> Boolean): T? = declarations.find { it is T && predicate(it) } as? T -@Suppress("UNCHECKED_CAST") -inline fun IrDeclarationContainer.filterDeclarations(predicate: (T) -> Boolean): List = - declarations.filter { it is T && predicate(it) } as List - fun IrValueParameter.hasDefaultValue(): Boolean = DFS.ifAny( listOf(this), { current -> (current.parent as? IrSimpleFunction)?.overriddenSymbols?.map { it.owner.valueParameters[current.index] } ?: listOf() }, { current -> current.defaultValue != null } ) -// In presence of `IrBlock`s, return the expression that actually serves as the value (the last one). -tailrec fun IrExpression.removeBlocks(): IrExpression? = when (this) { - is IrBlock -> (statements.last() as? IrExpression)?.removeBlocks() - else -> this -} - fun ReferenceSymbolTable.referenceClassifier(classifier: ClassifierDescriptor): IrClassifierSymbol = when (classifier) { is TypeParameterDescriptor -> @@ -403,19 +380,10 @@ fun ReferenceSymbolTable.referenceFunction(callable: CallableDescriptor): IrFunc } /** - * Create new call based on given [call] and [newFunction] + * Create new call based on given [call] and [newSymbol] * [receiversAsArguments]: optionally convert call with dispatch receiver to static call - * [argumentsAsReceivers]: optionally convert static call to call with dispatch receiver + * [argumentsAsDispatchers]: optionally convert static call to call with dispatch receiver */ - -fun irConstructorCall( - call: IrFunctionAccessExpression, - newFunction: IrConstructor, - receiversAsArguments: Boolean = false, - argumentsAsReceivers: Boolean = false -): IrConstructorCall = - irConstructorCall(call, newFunction.symbol, receiversAsArguments, argumentsAsReceivers) - fun irConstructorCall( call: IrFunctionAccessExpression, newSymbol: IrConstructorSymbol, @@ -568,42 +536,6 @@ val IrFunctionReference.typeSubstitutionMap: Map val IrFunctionAccessExpression.typeSubstitutionMap: Map get() = getTypeSubstitutionMap(symbol.owner) -// Note: there is not enough information in a descriptor to choose between an enum entry and its corresponding class, -// so the entry itself is chosen in that case. -fun SymbolTable.referenceMember(descriptor: DeclarationDescriptor, correspondingClassForEnum: Boolean = false): IrSymbol = - descriptor.accept( - object : DeclarationDescriptorVisitorEmptyBodies() { - override fun visitClassDescriptor(descriptor: ClassDescriptor, data: Unit?) = - if (DescriptorUtils.isEnumEntry(descriptor) && !correspondingClassForEnum) - referenceEnumEntry(descriptor) - else - referenceClass(descriptor) - - override fun visitConstructorDescriptor(constructorDescriptor: ConstructorDescriptor, data: Unit?) = - referenceConstructor(descriptor as ClassConstructorDescriptor) - - override fun visitFunctionDescriptor(descriptor: FunctionDescriptor, data: Unit?) = referenceSimpleFunction(descriptor) - - override fun visitPropertyDescriptor(descriptor: PropertyDescriptor, data: Unit?) = referenceProperty(descriptor) - - override fun visitTypeParameterDescriptor(descriptor: TypeParameterDescriptor, data: Unit?) = referenceTypeParameter(descriptor) - - override fun visitTypeAliasDescriptor(descriptor: TypeAliasDescriptor, data: Unit?) = referenceTypeAlias(descriptor) - - override fun visitDeclarationDescriptor(descriptor: DeclarationDescriptor?, data: Unit?): IrSymbol { - throw AssertionError("Unexpected member descriptor: $descriptor") - } - }, - null - ) - -fun SymbolTable.findOrDeclareExternalPackageFragment(descriptor: PackageFragmentDescriptor) = - referenceExternalPackageFragment(descriptor).also { - if (!it.isBound) { - declareExternalPackageFragment(descriptor) - } - }.owner - val IrDeclaration.isFileClass: Boolean get() = origin == IrDeclarationOrigin.FILE_CLASS || origin == IrDeclarationOrigin.SYNTHETIC_FILE_CLASS diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/KotlinUtils.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/KotlinUtils.kt deleted file mode 100644 index 885c264291f..00000000000 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/KotlinUtils.kt +++ /dev/null @@ -1,18 +0,0 @@ -/* - * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. - * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. - */ - -package org.jetbrains.kotlin.ir.util - -import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor -import org.jetbrains.kotlin.descriptors.ClassDescriptor -import org.jetbrains.kotlin.incremental.components.NoLookupLocation -import org.jetbrains.kotlin.name.Name -import org.jetbrains.kotlin.resolve.scopes.MemberScope - -inline fun ClassDescriptor.findFirstFunction(name: String, predicate: (CallableMemberDescriptor) -> Boolean) = - unsubstitutedMemberScope.findFirstFunction(name, predicate) - -inline fun MemberScope.findFirstFunction(name: String, predicate: (CallableMemberDescriptor) -> Boolean) = - getContributedFunctions(Name.identifier(name), NoLookupLocation.FROM_BACKEND).first(predicate) \ No newline at end of file diff --git a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/LegacyDescriptorUtils.kt b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/LegacyDescriptorUtils.kt index 486a095f6d0..cc98d91a0ac 100644 --- a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/LegacyDescriptorUtils.kt +++ b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/LegacyDescriptorUtils.kt @@ -5,14 +5,12 @@ package org.jetbrains.kotlin.backend.common.serialization -import org.jetbrains.kotlin.backend.common.descriptors.propertyIfAccessor import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.descriptors.konan.kotlinLibrary import org.jetbrains.kotlin.library.metadata.DeserializedSourceFile import org.jetbrains.kotlin.library.metadata.KlibMetadataDeserializedPackageFragment import org.jetbrains.kotlin.library.metadata.KlibMetadataProtoBuf import org.jetbrains.kotlin.name.Name -import org.jetbrains.kotlin.resolve.OverridingUtil import org.jetbrains.kotlin.resolve.checkers.ExpectedActualDeclarationChecker import org.jetbrains.kotlin.resolve.descriptorUtil.module import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedPropertyDescriptor @@ -29,11 +27,6 @@ tailrec fun DeclarationDescriptor.findPackage(): PackageFragmentDescriptor { else this.containingDeclaration!!.findPackage() } -fun DeclarationDescriptor.findTopLevelDescriptor(): DeclarationDescriptor { - return if (this.containingDeclaration is PackageFragmentDescriptor) this.propertyIfAccessor - else this.containingDeclaration!!.findTopLevelDescriptor() -} - // This is Native specific. Try to eliminate. val ModuleDescriptor.isForwardDeclarationModule get() = name == Name.special("") @@ -57,4 +50,4 @@ fun CallableMemberDescriptor.findSourceFile(): SourceFile { this, proto.getExtension(KlibMetadataProtoBuf.propertyFile)) else -> TODO() } -} \ No newline at end of file +} diff --git a/plugins/scripting/scripting-ide-services/src/org/jetbrains/kotlin/scripting/ide_services/compiler/impl/KJvmReplCompleter.kt b/plugins/scripting/scripting-ide-services/src/org/jetbrains/kotlin/scripting/ide_services/compiler/impl/KJvmReplCompleter.kt index 29219291b8a..5d6cf731077 100644 --- a/plugins/scripting/scripting-ide-services/src/org/jetbrains/kotlin/scripting/ide_services/compiler/impl/KJvmReplCompleter.kt +++ b/plugins/scripting/scripting-ide-services/src/org/jetbrains/kotlin/scripting/ide_services/compiler/impl/KJvmReplCompleter.kt @@ -7,7 +7,6 @@ package org.jetbrains.kotlin.scripting.ide_services.compiler.impl import com.intellij.psi.PsiElement import com.intellij.psi.tree.TokenSet -import org.jetbrains.kotlin.backend.common.onlyIf import org.jetbrains.kotlin.builtins.isFunctionType import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.descriptors.impl.LocalVariableDescriptor @@ -236,7 +235,9 @@ private class KJvmReplCompleter( ) Triple(it, presentation, (presentation.presentableText + presentation.tailText).toLowerCase()) } - .onlyIf({ isSortNeeded }) { it.sortedBy { descTriple -> descTriple.third } } + .let { + if (isSortNeeded) it.sortedBy { descTriple -> descTriple.third } else it + } .forEach { val descriptor = it.first val (rawName, presentableText, tailText, completionText) = it.second