From 30bcde982154773f4f60d1f72f40d14590db3d20 Mon Sep 17 00:00:00 2001 From: Brian Norman Date: Wed, 19 Aug 2020 22:17:37 -0500 Subject: [PATCH] Fix as many deprecation errors as possible --- .../main/kotlin/com/bnorm/power/AssertTree.kt | 4 +- .../kotlin/com/bnorm/power/IrStackVariable.kt | 1 + .../bnorm/power/PowerAssertCallTransformer.kt | 57 ++++++++++--------- settings.gradle.kts | 8 --- 4 files changed, 33 insertions(+), 37 deletions(-) diff --git a/kotlin-power-assert/src/main/kotlin/com/bnorm/power/AssertTree.kt b/kotlin-power-assert/src/main/kotlin/com/bnorm/power/AssertTree.kt index ae3ce22c247..bb02f964152 100644 --- a/kotlin-power-assert/src/main/kotlin/com/bnorm/power/AssertTree.kt +++ b/kotlin-power-assert/src/main/kotlin/com/bnorm/power/AssertTree.kt @@ -32,7 +32,7 @@ sealed class Node { val children: List get() = mutableChildren protected fun dump(builder: StringBuilder, indent: Int) { - builder.append(" ".repeat(indent)).append(this).appendln() + builder.append(" ".repeat(indent)).append(this).appendLine() for (child in children) { child.dump(builder, indent + 1) } @@ -102,7 +102,7 @@ fun buildAssertTree(expression: IrExpression): RootNode { } override fun visitCall(expression: IrCall, data: Node) { - if (expression.symbol.descriptor.name.asString() == "EQEQ" && expression.origin == IrStatementOrigin.EXCLEQ) { + if (expression.symbol.owner.name.asString() == "EQEQ" && expression.origin == IrStatementOrigin.EXCLEQ) { // Skip the EQEQ part of a EXCLEQ call expression.acceptChildren(this, data) } else { diff --git a/kotlin-power-assert/src/main/kotlin/com/bnorm/power/IrStackVariable.kt b/kotlin-power-assert/src/main/kotlin/com/bnorm/power/IrStackVariable.kt index e9e184ca669..6ef3aa0c5dc 100644 --- a/kotlin-power-assert/src/main/kotlin/com/bnorm/power/IrStackVariable.kt +++ b/kotlin-power-assert/src/main/kotlin/com/bnorm/power/IrStackVariable.kt @@ -63,6 +63,7 @@ fun IrBuilderWithScope.buildMessage( val columnOffset: Int = when (original) { is IrMemberAccessExpression -> { + // TODO IrFunction doesn't have 'isInfix' as a property val descriptor = original.symbol.descriptor when { descriptor is FunctionDescriptor && descriptor.isInfix -> source.indexOf(descriptor.name.asString()) diff --git a/kotlin-power-assert/src/main/kotlin/com/bnorm/power/PowerAssertCallTransformer.kt b/kotlin-power-assert/src/main/kotlin/com/bnorm/power/PowerAssertCallTransformer.kt index 66b60fb5783..34b856150c4 100644 --- a/kotlin-power-assert/src/main/kotlin/com/bnorm/power/PowerAssertCallTransformer.kt +++ b/kotlin-power-assert/src/main/kotlin/com/bnorm/power/PowerAssertCallTransformer.kt @@ -23,11 +23,7 @@ import org.jetbrains.kotlin.backend.common.ir.asSimpleLambda import org.jetbrains.kotlin.backend.common.ir.inline import org.jetbrains.kotlin.backend.common.lower.DeclarationIrBuilder import org.jetbrains.kotlin.backend.common.lower.at -import org.jetbrains.kotlin.backend.common.serialization.findPackage -import org.jetbrains.kotlin.builtins.isBuiltinFunctionalType -import org.jetbrains.kotlin.descriptors.FunctionDescriptor import org.jetbrains.kotlin.descriptors.Visibilities -import org.jetbrains.kotlin.incremental.components.NoLookupLocation import org.jetbrains.kotlin.ir.IrElement import org.jetbrains.kotlin.ir.builders.IrBuilderWithScope import org.jetbrains.kotlin.ir.builders.declarations.buildFun @@ -48,18 +44,21 @@ import org.jetbrains.kotlin.ir.expressions.IrStatementOrigin import org.jetbrains.kotlin.ir.expressions.IrStringConcatenation import org.jetbrains.kotlin.ir.expressions.impl.IrFunctionExpressionImpl import org.jetbrains.kotlin.ir.symbols.IrFunctionSymbol +import org.jetbrains.kotlin.ir.types.IrSimpleType +import org.jetbrains.kotlin.ir.types.IrType +import org.jetbrains.kotlin.ir.types.IrTypeArgument +import org.jetbrains.kotlin.ir.types.IrTypeProjection import org.jetbrains.kotlin.ir.types.getClass +import org.jetbrains.kotlin.ir.types.isBoolean +import org.jetbrains.kotlin.ir.types.isSubtypeOf import org.jetbrains.kotlin.ir.util.functions -import org.jetbrains.kotlin.ir.util.referenceFunction +import org.jetbrains.kotlin.ir.util.isFunctionOrKFunction import org.jetbrains.kotlin.ir.visitors.IrElementVisitorVoid import org.jetbrains.kotlin.ir.visitors.acceptChildrenVoid import org.jetbrains.kotlin.ir.visitors.acceptVoid import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe -import org.jetbrains.kotlin.types.KotlinType -import org.jetbrains.kotlin.types.typeUtil.isBoolean -import org.jetbrains.kotlin.types.typeUtil.isSubtypeOf import org.jetbrains.kotlin.util.OperatorNameConventions import java.io.File @@ -91,16 +90,18 @@ class PowerAssertCallTransformer( } override fun visitCall(expression: IrCall): IrExpression { - val function = expression.symbol.descriptor - if (functions.none { function.fqNameSafe == it }) + // TODO expression.symbol.owner.fqNameSafe includes the wrapping ClassKt while descriptor doesn't + val fqName = expression.symbol.descriptor.fqNameSafe + if (functions.none { fqName == it }) return super.visitCall(expression) - val delegate = findDelegate(function) ?: run { + val delegate = findDelegate(fqName) ?: run { // Find a valid delegate function or do not translate // TODO log a warning return super.visitCall(expression) } + val function = expression.symbol.owner val assertionArgument = expression.getValueArgument(0)!! val messageArgument = if (function.valueParameters.size == 2) expression.getValueArgument(1) else null @@ -143,13 +144,11 @@ class PowerAssertCallTransformer( fun buildCall(builder: IrBuilderWithScope, message: IrExpression): IrExpression } - private fun findDelegate(function: FunctionDescriptor): FunctionDelegate? { - fun KotlinType.toIrType() = context.typeTranslator.translateType(this) - - return context.findOverloads(function) + private fun findDelegate(fqName: FqName): FunctionDelegate? { + return context.findOverloads(fqName) .mapNotNull { overload -> // TODO allow other signatures than (Boolean, String) and (Boolean, () -> String)) - val parameters = overload.descriptor.valueParameters + val parameters = overload.owner.valueParameters if (parameters.size != 2) return@mapNotNull null if (!parameters[0].type.isBoolean()) return@mapNotNull null @@ -157,7 +156,7 @@ class PowerAssertCallTransformer( isStringSupertype(parameters[1].type) -> { object : FunctionDelegate { override fun buildCall(builder: IrBuilderWithScope, message: IrExpression): IrExpression = with(builder) { - irCall(overload, type = overload.descriptor.returnType!!.toIrType()).apply { + irCall(overload, type = overload.owner.returnType).apply { putValueArgument(0, irFalse()) putValueArgument(1, message) } @@ -181,28 +180,32 @@ class PowerAssertCallTransformer( parent = scope.parent } val expression = IrFunctionExpressionImpl(-1, -1, context.irBuiltIns.stringType, lambda, IrStatementOrigin.LAMBDA) - irCall(overload, type = overload.descriptor.returnType!!.toIrType()).apply { + irCall(overload, type = overload.owner.returnType).apply { putValueArgument(0, irFalse()) putValueArgument(1, expression) } } } } - else -> null + else -> { + null + } } } .singleOrNull() } - private fun isStringFunction(type: KotlinType): Boolean = - type.isBuiltinFunctionalType && type.arguments.size == 1 && isStringSupertype(type.arguments.first().type) + private fun isStringFunction(type: IrType): Boolean = + type.isFunctionOrKFunction() && type is IrSimpleType && (type.arguments.size == 1 && isStringSupertype(type.arguments.first())) - private fun isStringSupertype(type: KotlinType): Boolean = - context.builtIns.stringType.isSubtypeOf(type) + private fun isStringSupertype(argument: IrTypeArgument): Boolean = + argument is IrTypeProjection && isStringSupertype(argument.type) + + private fun isStringSupertype(type: IrType): Boolean = + context.irBuiltIns.stringType.isSubtypeOf(type, context.irBuiltIns) } // TODO is this the best way to find overload functions? -private fun IrPluginContext.findOverloads(function: FunctionDescriptor): List = - function.findPackage().getMemberScope() - .getContributedFunctions(function.name, NoLookupLocation.FROM_BACKEND) - .map { symbolTable.referenceFunction(it) } +private fun IrPluginContext.findOverloads(fqName: FqName): List { + return referenceFunctions(fqName).toList() +} diff --git a/settings.gradle.kts b/settings.gradle.kts index dc76dad50dd..ecb6a630422 100644 --- a/settings.gradle.kts +++ b/settings.gradle.kts @@ -1,11 +1,3 @@ -pluginManagement { - repositories { - mavenCentral() - gradlePluginPortal() - maven ("https://dl.bintray.com/kotlin/kotlin-eap") - } -} - rootProject.name = "kotlin-power-assert" include(":kotlin-power-assert")