From b813f22cfe80ec673e93c693223c6d8a2abf7903 Mon Sep 17 00:00:00 2001 From: Mikhail Glukhikh Date: Fri, 12 Jul 2019 15:23:28 +0300 Subject: [PATCH] Extract part of utility FIR transformers into TransformUtils --- .../transformers/FirBodyResolveTransformer.kt | 77 ++-------------- .../FirCallCompleterTransformer.kt | 13 --- .../resolve/transformers/TransformUtils.kt | 88 +++++++++++++++++++ 3 files changed, 93 insertions(+), 85 deletions(-) create mode 100644 compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/TransformUtils.kt diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirBodyResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirBodyResolveTransformer.kt index b3dcb24a5c9..508536669d4 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirBodyResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirBodyResolveTransformer.kt @@ -696,7 +696,7 @@ open class FirBodyResolveTransformer( ) } - qualifiedAccess.transformChildren(ReplaceInArguments, replacements.toMap()) + qualifiedAccess.transformChildren(MapArguments, replacements.toMap()) if (completionMode == KotlinConstraintSystemCompleter.ConstraintSystemCompletionMode.FULL) { @@ -1132,23 +1132,9 @@ private fun inferenceComponents(session: FirSession, jump: ReturnTypeCalculatorW class ReturnTypeCalculatorWithJump(val session: FirSession, val scopeSession: ScopeSession) : ReturnTypeCalculator { - - val storeType = object : FirTransformer() { - override fun transformElement(element: E, data: FirTypeRef): CompositeTransformResult { - return element.compose() - } - - override fun transformImplicitTypeRef( - implicitTypeRef: FirImplicitTypeRef, - data: FirTypeRef - ): CompositeTransformResult { - return data.compose() - } - } - private fun cycleErrorType(declaration: FirTypedDeclaration): FirResolvedTypeRef? { if (declaration.returnTypeRef is FirComputingImplicitTypeRef) { - declaration.transformReturnTypeRef(storeType, FirErrorTypeRefImpl(session, null, "cycle")) + declaration.transformReturnTypeRef(TransformImplicitType, FirErrorTypeRefImpl(session, null, "cycle")) return declaration.returnTypeRef as FirResolvedTypeRef } return null @@ -1158,7 +1144,7 @@ class ReturnTypeCalculatorWithJump(val session: FirSession, val scopeSession: Sc if (declaration is FirValueParameter && declaration.returnTypeRef is FirImplicitTypeRef) { // TODO? - declaration.transformReturnTypeRef(storeType, FirErrorTypeRefImpl(session, null, "Unsupported: implicit VP type")) + declaration.transformReturnTypeRef(TransformImplicitType, FirErrorTypeRefImpl(session, null, "Unsupported: implicit VP type")) } val returnTypeRef = declaration.returnTypeRef if (returnTypeRef is FirResolvedTypeRef) return returnTypeRef @@ -1183,11 +1169,11 @@ class ReturnTypeCalculatorWithJump(val session: FirSession, val scopeSession: Sc "I don't know what todo" ) - declaration.transformReturnTypeRef(storeType, FirComputingImplicitTypeRef) + declaration.transformReturnTypeRef(TransformImplicitType, FirComputingImplicitTypeRef) val transformer = FirDesignatedBodyResolveTransformer( (listOf(file) + outerClasses.filterNotNull().asReversed() + listOf(declaration)).iterator(), - file.session, + file.fileSession, scopeSession ) @@ -1262,57 +1248,4 @@ interface ReturnTypeCalculator { fun tryCalculateReturnType(declaration: FirTypedDeclaration): FirResolvedTypeRef } -private object StoreNameReference : FirTransformer() { - override fun transformElement(element: E, data: FirNamedReference): CompositeTransformResult { - return element.compose() - } - override fun transformNamedReference( - namedReference: FirNamedReference, - data: FirNamedReference - ): CompositeTransformResult { - return data.compose() - } -} - -internal object StoreType : FirTransformer() { - override fun transformElement(element: E, data: FirTypeRef): CompositeTransformResult { - return element.compose() - } - - override fun transformTypeRef(typeRef: FirTypeRef, data: FirTypeRef): CompositeTransformResult { - return data.compose() - } -} - -internal object StoreExplicitReceiver : FirTransformer() { - override fun transformElement(element: E, data: FirExpression): CompositeTransformResult { - return element.compose() - } - - override fun transformExpression(expression: FirExpression, data: FirExpression): CompositeTransformResult { - return data.compose() - } - - -} - -private object ReplaceInArguments : FirTransformer>() { - override fun transformElement(element: E, data: Map): CompositeTransformResult { - return ((data[element] ?: element) as E).compose() - } - - override fun transformFunctionCall( - functionCall: FirFunctionCall, - data: Map - ): CompositeTransformResult { - return (functionCall.transformChildren(this, data) as FirStatement).compose() - } - - override fun transformWrappedArgumentExpression( - wrappedArgumentExpression: FirWrappedArgumentExpression, - data: Map - ): CompositeTransformResult { - return (wrappedArgumentExpression.transformChildren(this, data) as FirStatement).compose() - } -} \ No newline at end of file diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirCallCompleterTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirCallCompleterTransformer.kt index 26a9b59820e..c47badd88bc 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirCallCompleterTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirCallCompleterTransformer.kt @@ -27,19 +27,6 @@ import org.jetbrains.kotlin.fir.visitors.FirTransformer import org.jetbrains.kotlin.fir.visitors.compose import org.jetbrains.kotlin.types.Variance -object StoreCalleeReference : FirTransformer() { - override fun transformElement(element: E, data: FirResolvedCallableReference): CompositeTransformResult { - return element.compose() - } - - override fun transformResolvedCallableReference( - resolvedCallableReference: FirResolvedCallableReference, - data: FirResolvedCallableReference - ): CompositeTransformResult { - return data.compose() - } -} - class FirCallCompleterTransformer( val session: FirSession, private val finalSubstitutor: ConeSubstitutor, diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/TransformUtils.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/TransformUtils.kt new file mode 100644 index 00000000000..64260ec2a04 --- /dev/null +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/TransformUtils.kt @@ -0,0 +1,88 @@ +/* + * 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.fir.resolve.transformers + +import org.jetbrains.kotlin.fir.FirElement +import org.jetbrains.kotlin.fir.FirNamedReference +import org.jetbrains.kotlin.fir.FirResolvedCallableReference +import org.jetbrains.kotlin.fir.expressions.FirFunctionCall +import org.jetbrains.kotlin.fir.expressions.FirStatement +import org.jetbrains.kotlin.fir.expressions.FirWrappedArgumentExpression +import org.jetbrains.kotlin.fir.types.FirImplicitTypeRef +import org.jetbrains.kotlin.fir.types.FirTypeRef +import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult +import org.jetbrains.kotlin.fir.visitors.FirTransformer +import org.jetbrains.kotlin.fir.visitors.compose + +internal object MapArguments : FirTransformer>() { + override fun transformElement(element: E, data: Map): CompositeTransformResult { + return ((data[element] ?: element) as E).compose() + } + + override fun transformFunctionCall( + functionCall: FirFunctionCall, + data: Map + ): CompositeTransformResult { + return (functionCall.transformChildren(this, data) as FirStatement).compose() + } + + override fun transformWrappedArgumentExpression( + wrappedArgumentExpression: FirWrappedArgumentExpression, + data: Map + ): CompositeTransformResult { + return (wrappedArgumentExpression.transformChildren(this, data) as FirStatement).compose() + } +} + +internal object StoreType : FirTransformer() { + override fun transformElement(element: E, data: FirTypeRef): CompositeTransformResult { + return element.compose() + } + + override fun transformTypeRef(typeRef: FirTypeRef, data: FirTypeRef): CompositeTransformResult { + return data.compose() + } +} + +internal object TransformImplicitType : FirTransformer() { + override fun transformElement(element: E, data: FirTypeRef): CompositeTransformResult { + return element.compose() + } + + override fun transformImplicitTypeRef( + implicitTypeRef: FirImplicitTypeRef, + data: FirTypeRef + ): CompositeTransformResult { + return data.compose() + } +} + + +internal object StoreNameReference : FirTransformer() { + override fun transformElement(element: E, data: FirNamedReference): CompositeTransformResult { + return element.compose() + } + + override fun transformNamedReference( + namedReference: FirNamedReference, + data: FirNamedReference + ): CompositeTransformResult { + return data.compose() + } +} + +internal object StoreCalleeReference : FirTransformer() { + override fun transformElement(element: E, data: FirResolvedCallableReference): CompositeTransformResult { + return element.compose() + } + + override fun transformResolvedCallableReference( + resolvedCallableReference: FirResolvedCallableReference, + data: FirResolvedCallableReference + ): CompositeTransformResult { + return data.compose() + } +}