Get rid of FirMemberFunction

2020-02-03 15:32:06 +03:00
parent 677129ad20
commit f20845ba40
14 changed files with 29 additions and 108 deletions
@@ -1003,7 +1003,7 @@ class HtmlFirDump internal constructor(private var linkResolver: FirLinkResolver
        }
    }

-    private fun FlowContent.describeVerbose(symbol: FirCallableSymbol<*>, fir: FirMemberFunction<*>) {
+    private fun FlowContent.describeVerbose(symbol: FirCallableSymbol<*>, fir: FirFunction<*>) {
        describeTypeParameters(fir)

        fir.receiverTypeRef?.let {
@@ -125,12 +125,11 @@ class JavaClassEnhancementScope(
        if (firMethod !is FirJavaMethod && firMethod !is FirJavaConstructor) {
            return original
        }
-        if (firMethod !is FirMemberFunction<*>) throw AssertionError()
        return enhanceMethod(firMethod, original.callableId, name)
    }

    private fun enhanceMethod(
-        firMethod: FirMemberFunction<*>,
+        firMethod: FirFunction<*>,
        methodId: CallableId,
        name: Name,
        isAccessor: Boolean = false,
@@ -149,13 +148,13 @@ class JavaClassEnhancementScope(
            }
        }

-        val overriddenMembers = firMethod.overriddenMembers()
+        val overriddenMembers = (firMethod as? FirSimpleFunction)?.overriddenMembers().orEmpty()
        val hasReceiver = overriddenMembers.any { it.receiverTypeRef != null }

        val newReceiverTypeRef = if (firMethod is FirJavaMethod && hasReceiver) {
            enhanceReceiverType(firMethod, overriddenMembers, memberContext)
        } else null
-        val newReturnTypeRef = if (firMethod is FirJavaConstructor) {
+        val newReturnTypeRef = if (firMethod !is FirJavaMethod) {
            firMethod.returnTypeRef
        } else {
            enhanceReturnType(firMethod, overriddenMembers, memberContext, predefinedEnhancementInfo)
@@ -218,7 +217,7 @@ class JavaClassEnhancementScope(
                    this.typeParameters += firMethod.typeParameters
                }
            }
-            else -> FirSimpleFunctionImpl(
+            is FirJavaMethod -> FirSimpleFunctionImpl(
                firMethod.source,
                this@JavaClassEnhancementScope.session,
                newReturnTypeRef,
@@ -232,6 +231,7 @@ class JavaClassEnhancementScope(
                this.valueParameters += newValueParameters
                this.typeParameters += firMethod.typeParameters
            }
+            else -> throw AssertionError("Unknown Java method to enhance: ${firMethod.render()}")
        }
        function.annotations += firMethod.annotations
        return function.symbol
@@ -258,7 +258,7 @@ class JavaClassEnhancementScope(
    private data class EnhanceValueParameterResult(val typeRef: FirResolvedTypeRef, val defaultValue: FirExpression?)

    private fun enhanceValueParameter(
-        ownerFunction: FirCallableMemberDeclaration<*>,
+        ownerFunction: FirFunction<*>,
        overriddenMembers: List<FirCallableMemberDeclaration<*>>,
        hasReceiver: Boolean,
        memberContext: FirJavaEnhancementContext,
@@ -338,14 +338,14 @@ class JavaClassEnhancementScope(
        }
    }

-    private fun FirCallableMemberDeclaration<*>.partsForValueParameter(
+    private fun FirFunction<*>.partsForValueParameter(
        typeQualifierResolver: FirAnnotationTypeQualifierResolver,
        overriddenMembers: List<FirCallableMemberDeclaration<*>>,
        // TODO: investigate if it's really can be a null (check properties' with extension overrides in Java)
        parameterContainer: FirAnnotationContainer?,
        methodContext: FirJavaEnhancementContext,
        typeInSignature: TypeInSignature
-    ) = parts(
+    ): EnhancementSignatureParts = (this as FirCallableMemberDeclaration<*>).parts(
        typeQualifierResolver,
        overriddenMembers,
        parameterContainer, false,
@@ -9,10 +9,7 @@ import com.intellij.psi.PsiElement
 import com.intellij.psi.tree.IElementType
 import org.jetbrains.kotlin.KtNodeTypes.*
 import org.jetbrains.kotlin.fir.*
-import org.jetbrains.kotlin.fir.declarations.FirAnonymousFunction
-import org.jetbrains.kotlin.fir.declarations.FirMemberFunction
-import org.jetbrains.kotlin.fir.declarations.FirRegularClass
-import org.jetbrains.kotlin.fir.declarations.FirTypeParameter
+import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.impl.FirErrorFunctionImpl
 import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind
 import org.jetbrains.kotlin.fir.diagnostics.FirSimpleDiagnostic
@@ -124,7 +121,7 @@ abstract class BaseFirBuilder<T>(val session: FirSession, val context: Context =
                                return@apply
                            }
                        }
-                        is FirMemberFunction<*> -> {
+                        is FirSimpleFunction -> {
                            if (firFunction.name.asString() == labelName) {
                                target.bind(firFunction)
                                return@apply
@@ -188,7 +188,7 @@ private class TypeAliasConstructorsSubstitutingScope(
 private typealias ConstructorCopyFactory<F> =
        F.(newReturnType: ConeKotlinType?, newValueParameterTypes: List<ConeKotlinType?>, newTypeParameters: List<FirTypeParameter>) -> F

-private class TypeAliasConstructorsSubstitutor<F : FirMemberFunction<F>>(
+private class TypeAliasConstructorsSubstitutor<F : FirFunction<F>>(
    private val typeAliasSymbol: FirTypeAliasSymbol,
    private val substitutor: ConeSubstitutor,
    private val copyFactory: ConstructorCopyFactory<F>
@@ -258,7 +258,7 @@ private fun prepareSubstitutingScopeForTypeAliasConstructors(
    )
 }

-private fun <F : FirMemberFunction<F>> prepareSubstitutorForTypeAliasConstructors(
+private fun <F : FirFunction<F>> prepareSubstitutorForTypeAliasConstructors(
    typeAliasSymbol: FirTypeAliasSymbol,
    expandedType: ConeClassLikeType,
    session: FirSession,
@@ -324,7 +324,7 @@ class FirCallCompletionResultsWriterTransformer(
        val syntheticCall = syntheticCall.transformChildren(this, data?.getExpectedType(syntheticCall)?.toExpectedType()) as D
        val calleeReference = syntheticCall.calleeReference as? FirNamedReferenceWithCandidate ?: return syntheticCall.compose()

-        val declaration = calleeReference.candidate.symbol.fir as? FirMemberFunction<*> ?: return syntheticCall.compose()
+        val declaration = calleeReference.candidate.symbol.fir as? FirSimpleFunction ?: return syntheticCall.compose()

        val typeRef = typeCalculator.tryCalculateReturnType(declaration)
        syntheticCall.replaceTypeRefWithSubstituted(calleeReference, typeRef)
@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.fir.visitors.*
 * DO NOT MODIFY IT MANUALLY
 */

-interface FirConstructor : FirMemberFunction<FirConstructor> {
+interface FirConstructor : FirFunction<FirConstructor>, FirCallableMemberDeclaration<FirConstructor> {
    override val source: FirSourceElement?
    override val session: FirSession
    override val resolvePhase: FirResolvePhase
@@ -1,51 +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.fir.declarations
-
-import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.FirSourceElement
-import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
-import org.jetbrains.kotlin.fir.expressions.FirBlock
-import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference
-import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
-import org.jetbrains.kotlin.fir.types.FirTypeRef
-import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedContainerSource
-import org.jetbrains.kotlin.fir.visitors.*
-
-/*
- * This file was generated automatically
- * DO NOT MODIFY IT MANUALLY
- */
-
-interface FirMemberFunction<F : FirMemberFunction<F>> : FirFunction<F>, FirCallableMemberDeclaration<F> {
-    override val source: FirSourceElement?
-    override val session: FirSession
-    override val resolvePhase: FirResolvePhase
-    override val returnTypeRef: FirTypeRef
-    override val receiverTypeRef: FirTypeRef?
-    override val controlFlowGraphReference: FirControlFlowGraphReference
-    override val typeParameters: List<FirTypeParameter>
-    override val valueParameters: List<FirValueParameter>
-    override val body: FirBlock?
-    override val name: Name
-    override val status: FirDeclarationStatus
-    override val containerSource: DeserializedContainerSource?
-    override val symbol: FirFunctionSymbol<F>
-    override val annotations: List<FirAnnotationCall>
-
-    override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitMemberFunction(this, data)
-
-    override fun <D> transformReturnTypeRef(transformer: FirTransformer<D>, data: D): FirMemberFunction<F>
-
-    override fun <D> transformReceiverTypeRef(transformer: FirTransformer<D>, data: D): FirMemberFunction<F>
-
-    override fun <D> transformControlFlowGraphReference(transformer: FirTransformer<D>, data: D): FirMemberFunction<F>
-
-    override fun <D> transformValueParameters(transformer: FirTransformer<D>, data: D): FirMemberFunction<F>
-
-    override fun <D> transformStatus(transformer: FirTransformer<D>, data: D): FirMemberFunction<F>
-}
@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.fir.visitors.*
 * DO NOT MODIFY IT MANUALLY
 */

-abstract class FirSimpleFunction : FirPureAbstractElement(), FirMemberFunction<FirSimpleFunction>, FirContractDescriptionOwner {
+abstract class FirSimpleFunction : FirPureAbstractElement(), FirFunction<FirSimpleFunction>, FirCallableMemberDeclaration<FirSimpleFunction>, FirContractDescriptionOwner {
    abstract override val source: FirSourceElement?
    abstract override val session: FirSession
    abstract override val resolvePhase: FirResolvePhase
@@ -36,9 +36,9 @@ abstract class FirSimpleFunction : FirPureAbstractElement(), FirMemberFunction<F
    abstract override val name: Name
    abstract override val status: FirDeclarationStatus
    abstract override val containerSource: DeserializedContainerSource?
+    abstract override val contractDescription: FirContractDescription
    abstract override val symbol: FirFunctionSymbol<FirSimpleFunction>
    abstract override val annotations: List<FirAnnotationCall>
-    abstract override val contractDescription: FirContractDescription

    override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitSimpleFunction(this, data)

@@ -45,8 +45,8 @@ open class FirSimpleFunctionImpl(
    override val valueParameters: MutableList<FirValueParameter> = mutableListOf()
    override var body: FirBlock? = null
    override var containerSource: DeserializedContainerSource? = null
-    override val annotations: MutableList<FirAnnotationCall> = mutableListOf()
    override var contractDescription: FirContractDescription = FirEmptyContractDescription
+    override val annotations: MutableList<FirAnnotationCall> = mutableListOf()

    init {
        symbol.bind(this)
@@ -60,8 +60,8 @@ open class FirSimpleFunctionImpl(
        valueParameters.forEach { it.accept(visitor, data) }
        body?.accept(visitor, data)
        status.accept(visitor, data)
-        annotations.forEach { it.accept(visitor, data) }
        contractDescription.accept(visitor, data)
+        annotations.forEach { it.accept(visitor, data) }
    }

    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirSimpleFunctionImpl {
@@ -72,8 +72,8 @@ open class FirSimpleFunctionImpl(
        transformValueParameters(transformer, data)
        body = body?.transformSingle(transformer, data)
        transformStatus(transformer, data)
-        annotations.transformInplace(transformer, data)
        transformContractDescription(transformer, data)
+        annotations.transformInplace(transformer, data)
        return this
    }

@@ -40,7 +40,6 @@ import org.jetbrains.kotlin.fir.declarations.FirSealedClass
 import org.jetbrains.kotlin.fir.declarations.FirTypeAlias
 import org.jetbrains.kotlin.fir.declarations.FirFunction
 import org.jetbrains.kotlin.fir.declarations.FirContractDescriptionOwner
-import org.jetbrains.kotlin.fir.declarations.FirMemberFunction
 import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
 import org.jetbrains.kotlin.fir.declarations.FirPropertyAccessor
 import org.jetbrains.kotlin.fir.declarations.FirConstructor
@@ -266,10 +265,6 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
        return transformElement(contractDescriptionOwner, data)
    }

-    open fun <F : FirMemberFunction<F>> transformMemberFunction(memberFunction: FirMemberFunction<F>, data: D): CompositeTransformResult<FirDeclaration> {
-        return transformElement(memberFunction, data)
-    }
-
    open fun transformSimpleFunction(simpleFunction: FirSimpleFunction, data: D): CompositeTransformResult<FirDeclaration> {
        return transformElement(simpleFunction, data)
    }
@@ -722,10 +717,6 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
        return transformContractDescriptionOwner(contractDescriptionOwner, data)
    }

-    final override fun <F : FirMemberFunction<F>> visitMemberFunction(memberFunction: FirMemberFunction<F>, data: D): CompositeTransformResult<FirDeclaration> {
-        return transformMemberFunction(memberFunction, data)
-    }
-
    final override fun visitSimpleFunction(simpleFunction: FirSimpleFunction, data: D): CompositeTransformResult<FirDeclaration> {
        return transformSimpleFunction(simpleFunction, data)
    }
@@ -40,7 +40,6 @@ import org.jetbrains.kotlin.fir.declarations.FirSealedClass
 import org.jetbrains.kotlin.fir.declarations.FirTypeAlias
 import org.jetbrains.kotlin.fir.declarations.FirFunction
 import org.jetbrains.kotlin.fir.declarations.FirContractDescriptionOwner
-import org.jetbrains.kotlin.fir.declarations.FirMemberFunction
 import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
 import org.jetbrains.kotlin.fir.declarations.FirPropertyAccessor
 import org.jetbrains.kotlin.fir.declarations.FirConstructor
@@ -196,8 +195,6 @@ abstract class FirVisitor<out R, in D> {

    open fun visitContractDescriptionOwner(contractDescriptionOwner: FirContractDescriptionOwner, data: D): R  = visitElement(contractDescriptionOwner, data)

-    open fun <F : FirMemberFunction<F>> visitMemberFunction(memberFunction: FirMemberFunction<F>, data: D): R  = visitElement(memberFunction, data)
-
    open fun visitSimpleFunction(simpleFunction: FirSimpleFunction, data: D): R  = visitElement(simpleFunction, data)

    open fun visitPropertyAccessor(propertyAccessor: FirPropertyAccessor, data: D): R  = visitElement(propertyAccessor, data)
@@ -40,7 +40,6 @@ import org.jetbrains.kotlin.fir.declarations.FirSealedClass
 import org.jetbrains.kotlin.fir.declarations.FirTypeAlias
 import org.jetbrains.kotlin.fir.declarations.FirFunction
 import org.jetbrains.kotlin.fir.declarations.FirContractDescriptionOwner
-import org.jetbrains.kotlin.fir.declarations.FirMemberFunction
 import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
 import org.jetbrains.kotlin.fir.declarations.FirPropertyAccessor
 import org.jetbrains.kotlin.fir.declarations.FirConstructor
@@ -264,10 +263,6 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
        visitElement(contractDescriptionOwner)
    }

-    open fun <F : FirMemberFunction<F>> visitMemberFunction(memberFunction: FirMemberFunction<F>) {
-        visitElement(memberFunction)
-    }
-
    open fun visitSimpleFunction(simpleFunction: FirSimpleFunction) {
        visitElement(simpleFunction)
    }
@@ -720,10 +715,6 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
        visitContractDescriptionOwner(contractDescriptionOwner)
    }

-    final override fun <F : FirMemberFunction<F>> visitMemberFunction(memberFunction: FirMemberFunction<F>, data: Nothing?) {
-        visitMemberFunction(memberFunction)
-    }
-
    final override fun visitSimpleFunction(simpleFunction: FirSimpleFunction, data: Nothing?) {
        visitSimpleFunction(simpleFunction)
    }
@@ -50,10 +50,9 @@ object FirTreeBuilder : AbstractFirTreeBuilder() {
    val function = element("Function", Declaration, callableDeclaration, controlFlowGraphOwner, targetElement, annotationContainer, typeParametersOwner, statement)

    val contractDescriptionOwner = element("ContractDescriptionOwner", Declaration)
-    val memberFunction = element("MemberFunction", Declaration, function, callableMemberDeclaration)
-    val simpleFunction = element("SimpleFunction", Declaration, memberFunction, contractDescriptionOwner)
+    val simpleFunction = element("SimpleFunction", Declaration, function, callableMemberDeclaration, contractDescriptionOwner)
    val propertyAccessor = element("PropertyAccessor", Declaration, function, contractDescriptionOwner)
-    val constructor = element("Constructor", Declaration, memberFunction)
+    val constructor = element("Constructor", Declaration, function, callableMemberDeclaration)
    val file = element("File", Declaration, annotationContainer, declaration)

    val anonymousFunction = element("AnonymousFunction", Declaration, function, expression)
@@ -260,16 +260,11 @@ object NodeConfigurator : AbstractFieldConfigurator<FirTreeBuilder>(FirTreeBuild
            +annotations
        }

-        memberFunction.configure {
-            withArg("F", memberFunction)
-            parentArg(function, "F", "F")
-            parentArg(callableMemberDeclaration, "F", "F")
-            +symbol("FirFunctionSymbol", "F")
-            +annotations
-        }
-
        simpleFunction.configure {
-            parentArg(memberFunction, "F", simpleFunction)
+            parentArg(function, "F", simpleFunction)
+            +symbol("FirFunctionSymbol<FirSimpleFunction>")
+            +annotations
+            parentArg(callableMemberDeclaration, "F", simpleFunction)
        }

        contractDescriptionOwner.configure {
@@ -310,7 +305,9 @@ object NodeConfigurator : AbstractFieldConfigurator<FirTreeBuilder>(FirTreeBuild
        }

        constructor.configure {
-            parentArg(memberFunction, "F", constructor)
+            parentArg(function, "F", constructor)
+            parentArg(callableMemberDeclaration, "F", constructor)
+            +annotations
            +symbol("FirConstructorSymbol")
            +field("delegatedConstructor", delegatedConstructorCall, nullable = true)
            +body(nullable = true)