From 38c1a50c1d00ad21f6a572b52f3d15d94bee0d66 Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Tue, 3 Dec 2019 18:39:39 +0300 Subject: [PATCH] [FIR] Resolve delegating constructor calls --- .../jetbrains/kotlin/fir/FirCallResolver.kt | 68 ++++++++++++++++- .../kotlin/fir/resolve/ResolveUtils.kt | 6 ++ .../fir/resolve/calls/InferenceCompletion.kt | 5 ++ ...rCallCompletionResultsWriterTransformer.kt | 15 ++++ .../resolve/transformers/TransformUtils.kt | 14 +++- .../body/resolve/FirBodyResolveTransformer.kt | 7 ++ .../FirExpressionsResolveTransformer.kt | 60 ++++++++++++++- .../resolve/delegatingConstructorCall.kt | 16 ++++ .../resolve/delegatingConstructorCall.txt | 76 +++++++++++++++++++ .../delegatingConstructorsAndTypeAliases.kt | 5 ++ .../delegatingConstructorsAndTypeAliases.txt | 14 ++++ .../expresssions/protectedVisibility.kt | 2 +- .../expresssions/protectedVisibility.txt | 2 +- .../j+k/KJKComplexHierarchyNestedLoop.kt | 2 +- .../fir/FirDiagnosticsTestGenerated.java | 10 +++ .../jetbrains/kotlin/fir/FirResolveBench.kt | 6 +- .../FirDelegatedConstructorCall.kt | 8 +- .../impl/FirDelegatedConstructorCallImpl.kt | 16 ++-- .../kotlin/fir/visitors/FirTransformer.kt | 18 ++--- .../kotlin/fir/visitors/FirVisitor.kt | 6 +- .../kotlin/fir/visitors/FirVisitorVoid.kt | 18 ++--- .../fir/tree/generator/FirTreeBuilder.kt | 2 +- .../generator/ImplementationConfigurator.kt | 10 +++ .../fir/tree/generator/NodeConfigurator.kt | 1 - ...nceInClosureInSuperConstructorCall.fir.txt | 6 +- 25 files changed, 339 insertions(+), 54 deletions(-) create mode 100644 compiler/fir/resolve/testData/resolve/delegatingConstructorCall.kt create mode 100644 compiler/fir/resolve/testData/resolve/delegatingConstructorCall.txt create mode 100644 compiler/fir/resolve/testData/resolve/delegatingConstructorsAndTypeAliases.kt create mode 100644 compiler/fir/resolve/testData/resolve/delegatingConstructorsAndTypeAliases.txt diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirCallResolver.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirCallResolver.kt index 60e89266425..f9d38e74719 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirCallResolver.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirCallResolver.kt @@ -11,6 +11,7 @@ import org.jetbrains.kotlin.fir.expressions.* import org.jetbrains.kotlin.fir.expressions.impl.FirExpressionStub import org.jetbrains.kotlin.fir.expressions.impl.FirResolvedQualifierImpl import org.jetbrains.kotlin.fir.references.FirNamedReference +import org.jetbrains.kotlin.fir.references.FirReference import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference import org.jetbrains.kotlin.fir.references.impl.FirBackingFieldReferenceImpl import org.jetbrains.kotlin.fir.references.impl.FirErrorNamedReferenceImpl @@ -29,16 +30,20 @@ import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirExpressions import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.resultType import org.jetbrains.kotlin.fir.resolve.transformers.phasedFir import org.jetbrains.kotlin.fir.scopes.FirScope +import org.jetbrains.kotlin.fir.scopes.ProcessorAction import org.jetbrains.kotlin.fir.scopes.impl.FirLocalScope import org.jetbrains.kotlin.fir.symbols.StandardClassIds import org.jetbrains.kotlin.fir.symbols.impl.* import org.jetbrains.kotlin.fir.symbols.invoke import org.jetbrains.kotlin.fir.types.ConeKotlinErrorType import org.jetbrains.kotlin.fir.types.ConeKotlinType +import org.jetbrains.kotlin.fir.types.FirTypeProjection import org.jetbrains.kotlin.fir.types.impl.FirResolvedTypeRefImpl +import org.jetbrains.kotlin.fir.visitors.compose import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.resolve.calls.inference.ConstraintSystemBuilder import org.jetbrains.kotlin.resolve.calls.results.TypeSpecificityComparator +import org.jetbrains.kotlin.resolve.calls.tasks.ExplicitReceiverKind import org.jetbrains.kotlin.resolve.descriptorUtil.HIDES_MEMBERS_NAME_LIST class FirCallResolver( @@ -107,6 +112,7 @@ class FirCallResolver( val nameReference = createResolvedNamedReference( functionCall.calleeReference, + name, reducedCandidates, result.currentApplicability ) @@ -171,6 +177,7 @@ class FirCallResolver( } val nameReference = createResolvedNamedReference( callee, + callee.name, reducedCandidates, result.currentApplicability ) @@ -264,6 +271,61 @@ class FirCallResolver( return true } + fun resolveDelegatingConstructorCall( + delegatedConstructorCall: FirDelegatedConstructorCall, + symbol: FirClassSymbol<*>, + typeArguments: List + ): FirDelegatedConstructorCall? { + val scope = symbol.fir.buildUseSiteMemberScope(session, scopeSession) ?: return null + val callInfo = CallInfo( + CallKind.Function, + explicitReceiver = null, + delegatedConstructorCall.arguments, + isSafeCall = false, + typeArguments = typeArguments, + session, + file, + implicitReceiverStack, + container + ) { it.resultType } + val candidateFactory = CandidateFactory(this, callInfo) + val candidates = mutableListOf() + + val className = symbol.classId.shortClassName + scope.processFunctionsByName(className) { + if (it is FirConstructorSymbol) { + candidates += candidateFactory.createCandidate( + it, + dispatchReceiverValue = null, + implicitExtensionReceiverValue = null, + ExplicitReceiverKind.NO_EXPLICIT_RECEIVER + ) + } + ProcessorAction.NEXT + } + return callResolver.selectCandidateFromGivenCandidates(delegatedConstructorCall, className, candidates) + } + + fun selectCandidateFromGivenCandidates(call: T, name: Name, candidates: Collection): T where T : FirResolvable, T : FirCall { + val result = CandidateCollector(this, resolutionStageRunner) + candidates.forEach { result.consumeCandidate(0, it) } + val bestCandidates = result.bestCandidates() + val reducedCandidates = if (result.currentApplicability < CandidateApplicability.SYNTHETIC_RESOLVED) { + bestCandidates.toSet() + } else { + conflictResolver.chooseMaximallySpecificCandidates(bestCandidates, discriminateGenerics = true) + } + + val nameReference = createResolvedNamedReference( + call.calleeReference, + name, + reducedCandidates, + result.currentApplicability + ) + + return call.transformCalleeReference(StoreNameReference, nameReference) as T + } + private fun createCallableReferencesConsumerForLHS( callableReferenceAccess: FirCallableReferenceAccess, lhs: DoubleColonLHS?, @@ -341,12 +403,12 @@ class FirCallResolver( } private fun createResolvedNamedReference( - namedReference: FirNamedReference, + reference: FirReference, + name: Name, candidates: Collection, applicability: CandidateApplicability ): FirNamedReference { - val name = namedReference.name - val source = namedReference.source + val source = reference.source return when { candidates.isEmpty() -> FirErrorNamedReferenceImpl( source, FirUnresolvedNameError(name) diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ResolveUtils.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ResolveUtils.kt index 3d45710322c..ddcec92d5af 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ResolveUtils.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ResolveUtils.kt @@ -19,10 +19,12 @@ import org.jetbrains.kotlin.fir.expressions.FirResolvedQualifier import org.jetbrains.kotlin.fir.expressions.impl.FirExpressionWithSmartcastImpl import org.jetbrains.kotlin.fir.references.FirErrorNamedReference import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference +import org.jetbrains.kotlin.fir.references.FirSuperReference import org.jetbrains.kotlin.fir.references.FirThisReference import org.jetbrains.kotlin.fir.render import org.jetbrains.kotlin.fir.resolve.calls.ConeInferenceContext import org.jetbrains.kotlin.fir.resolve.calls.FirNamedReferenceWithCandidate +import org.jetbrains.kotlin.fir.resolve.diagnostics.FirUnresolvedNameError import org.jetbrains.kotlin.fir.resolve.substitution.AbstractConeSubstitutor import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.resultType import org.jetbrains.kotlin.fir.resolvedTypeFromPrototype @@ -35,6 +37,7 @@ import org.jetbrains.kotlin.fir.types.impl.ConeClassLikeTypeImpl import org.jetbrains.kotlin.fir.types.impl.ConeTypeParameterTypeImpl import org.jetbrains.kotlin.fir.types.impl.FirErrorTypeRefImpl import org.jetbrains.kotlin.fir.types.impl.FirResolvedTypeRefImpl +import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.types.Variance import org.jetbrains.kotlin.utils.addToStdlib.safeAs @@ -345,6 +348,9 @@ fun BodyResolveComponents.typeFromCallee(access: T): FirReso val implicitReceiver = implicitReceiverStack[labelName] FirResolvedTypeRefImpl(null, implicitReceiver?.type ?: ConeKotlinErrorType("Unresolved this@$labelName")) } + is FirSuperReference -> { + newCallee.superTypeRef as? FirResolvedTypeRef ?: FirErrorTypeRefImpl(newCallee.source, FirUnresolvedNameError(Name.identifier("super"))) + } else -> error("Failed to extract type from: $newCallee") } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/InferenceCompletion.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/InferenceCompletion.kt index f6633b30c04..631d80bc0ad 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/InferenceCompletion.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/InferenceCompletion.kt @@ -259,6 +259,11 @@ class ConstraintSystemCompleter(val components: InferenceComponents) { this.returnExpressions().forEach { it.processAllContainingCallCandidates(processBlocks, processor) } } } + + is FirDelegatedConstructorCall -> { + processCandidateIfApplicable(processor) + this.arguments.forEach { it.processAllContainingCallCandidates(processBlocks, processor) } + } } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirCallCompletionResultsWriterTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirCallCompletionResultsWriterTransformer.kt index 0635a4538f9..344602e9b83 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirCallCompletionResultsWriterTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirCallCompletionResultsWriterTransformer.kt @@ -186,6 +186,21 @@ class FirCallCompletionResultsWriterTransformer( } + override fun transformDelegatedConstructorCall( + delegatedConstructorCall: FirDelegatedConstructorCall, + data: Nothing? + ): CompositeTransformResult { + val calleeReference = delegatedConstructorCall.calleeReference as? FirNamedReferenceWithCandidate ?: return delegatedConstructorCall.compose() + + val subCandidate = calleeReference.candidate + val result = delegatedConstructorCall.transformArguments(this, data) + return result.transformCalleeReference(StoreCalleeReference, FirResolvedNamedReferenceImpl( + calleeReference.source, + calleeReference.name, + calleeReference.candidateSymbol + )).compose() + } + private fun computeTypeArguments( candidate: Candidate ): List { 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 index 95b958732cc..eb64e40641e 100644 --- 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 @@ -11,8 +11,7 @@ import org.jetbrains.kotlin.fir.expressions.FirExpression 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.references.FirNamedReference -import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference +import org.jetbrains.kotlin.fir.references.* import org.jetbrains.kotlin.fir.scopes.impl.withReplacedConeType import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult @@ -75,6 +74,17 @@ internal object StoreNameReference : FirDefaultTransformer() ): CompositeTransformResult { return data.compose() } + + override fun transformThisReference(thisReference: FirThisReference, data: FirNamedReference): CompositeTransformResult { + return data.compose() + } + + override fun transformSuperReference( + superReference: FirSuperReference, + data: FirNamedReference + ): CompositeTransformResult { + return data.compose() + } } internal object StoreCalleeReference : FirTransformer() { diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirBodyResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirBodyResolveTransformer.kt index 2959e1fdc5c..084ce18a3e8 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirBodyResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirBodyResolveTransformer.kt @@ -147,6 +147,13 @@ open class FirBodyResolveTransformer( return expressionsTransformer.transformAnnotationCall(annotationCall, data) } + override fun transformDelegatedConstructorCall( + delegatedConstructorCall: FirDelegatedConstructorCall, + data: ResolutionMode + ): CompositeTransformResult { + return expressionsTransformer.transformDelegatedConstructorCall(delegatedConstructorCall, data) + } + // ------------------------------------- Declarations ------------------------------------- override fun transformDeclaration(declaration: FirDeclaration, data: ResolutionMode): CompositeTransformResult { diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt index aff44f8e5c7..540e76b41e5 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt @@ -17,6 +17,7 @@ import org.jetbrains.kotlin.fir.expressions.impl.FirVariableAssignmentImpl import org.jetbrains.kotlin.fir.references.FirDelegateFieldReference import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference import org.jetbrains.kotlin.fir.references.FirSuperReference +import org.jetbrains.kotlin.fir.references.FirThisReference import org.jetbrains.kotlin.fir.references.impl.FirErrorNamedReferenceImpl import org.jetbrains.kotlin.fir.references.impl.FirExplicitThisReference import org.jetbrains.kotlin.fir.references.impl.FirSimpleNamedReference @@ -30,18 +31,19 @@ import org.jetbrains.kotlin.fir.resolve.transformers.StoreReceiver import org.jetbrains.kotlin.fir.resolvedTypeFromPrototype import org.jetbrains.kotlin.fir.scopes.impl.withReplacedConeType import org.jetbrains.kotlin.fir.symbols.StandardClassIds +import org.jetbrains.kotlin.fir.symbols.impl.ConeClassLookupTagWithFixedSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol import org.jetbrains.kotlin.fir.symbols.invoke import org.jetbrains.kotlin.fir.types.* -import org.jetbrains.kotlin.fir.types.impl.ConeClassLikeTypeImpl -import org.jetbrains.kotlin.fir.types.impl.FirErrorTypeRefImpl -import org.jetbrains.kotlin.fir.types.impl.FirResolvedTypeRefImpl +import org.jetbrains.kotlin.fir.types.impl.* import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult import org.jetbrains.kotlin.fir.visitors.compose import org.jetbrains.kotlin.fir.visitors.transformSingle import org.jetbrains.kotlin.ir.expressions.IrConstKind import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.Name +import org.jetbrains.kotlin.types.Variance class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) : FirPartialBodyResolveTransformer(transformer) { private val callResolver: FirCallResolver get() = components.callResolver @@ -426,6 +428,58 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) : }.compose() } + private fun ConeKotlinTypeProjection.toFirTypeProjection(): FirTypeProjection = when (this) { + is ConeStarProjection -> FirStarProjectionImpl(null) + else -> { + val variance = when (kind) { + ProjectionKind.IN -> Variance.IN_VARIANCE + ProjectionKind.OUT -> Variance.OUT_VARIANCE + ProjectionKind.INVARIANT -> Variance.INVARIANT + ProjectionKind.STAR -> throw IllegalStateException() + } + val type = when (this) { + is ConeKotlinTypeProjectionIn -> type + is ConeKotlinTypeProjectionOut -> type + is ConeStarProjection -> throw IllegalStateException() + else -> this as ConeKotlinType + } + FirTypeProjectionWithVarianceImpl( + null, FirResolvedTypeRefImpl(null, type), variance + ) + } + } + + override fun transformDelegatedConstructorCall( + delegatedConstructorCall: FirDelegatedConstructorCall, + data: ResolutionMode + ): CompositeTransformResult { + if (transformer.implicitTypeOnly) return delegatedConstructorCall.compose() + delegatedConstructorCall.transformChildren(transformer, ResolutionMode.ContextDependent) + val typeArguments: List + val symbol: FirClassSymbol<*> = when (val reference = delegatedConstructorCall.calleeReference) { + is FirThisReference -> { + typeArguments = emptyList() + reference.boundSymbol as? FirClassSymbol<*> ?: return delegatedConstructorCall.compose() + } + is FirSuperReference -> { + // TODO: unresolved supertype + val supertype = reference.superTypeRef.coneTypeSafe() ?: return delegatedConstructorCall.compose() + typeArguments = supertype.typeArguments.takeIf { it.isNotEmpty() }?.map { it.toFirTypeProjection() } ?: emptyList() + val expandedSupertype = supertype.fullyExpandedType(session) + val lookupTag = expandedSupertype.lookupTag + if (lookupTag is ConeClassLookupTagWithFixedSymbol) { + lookupTag.symbol + } else { + // TODO: support locals + symbolProvider.getSymbolByLookupTag(lookupTag) ?: return delegatedConstructorCall.compose() + } as FirClassSymbol<*> + } + else -> return delegatedConstructorCall.compose() + } + val result = callResolver.resolveDelegatingConstructorCall(delegatedConstructorCall, symbol, typeArguments) ?: return delegatedConstructorCall.compose() + return callCompleter.completeCall(result, noExpectedType).compose() + } + // ------------------------------------------------------------------------------------------------ internal fun storeTypeFromCallee(access: T) where T : FirQualifiedAccess, T : FirExpression { diff --git a/compiler/fir/resolve/testData/resolve/delegatingConstructorCall.kt b/compiler/fir/resolve/testData/resolve/delegatingConstructorCall.kt new file mode 100644 index 00000000000..a3a5326a4f5 --- /dev/null +++ b/compiler/fir/resolve/testData/resolve/delegatingConstructorCall.kt @@ -0,0 +1,16 @@ +fun materialize(): K = null!! + +open class A1(val x: String) +class B1 : A1(materialize()) + +open class A2(val x: Int) +class B2 : A2(1 + 1) + +open class A3(x: String, y: String = "") { + constructor(x: String, b: Boolean = true) : this(x, x) +} + +class B3_1 : A3("") +class B3_2 : A3("", "asas") +class B3_3 : A3("", true) +class B3_4 : A3("", Unit) diff --git a/compiler/fir/resolve/testData/resolve/delegatingConstructorCall.txt b/compiler/fir/resolve/testData/resolve/delegatingConstructorCall.txt new file mode 100644 index 00000000000..f26f5924f6f --- /dev/null +++ b/compiler/fir/resolve/testData/resolve/delegatingConstructorCall.txt @@ -0,0 +1,76 @@ +FILE: delegatingConstructorCall.kt + public final fun materialize(): R|K| { + ^materialize when (lval : R|kotlin/Nothing?| = Null(null)) { + ==($subj$, Null(null)) -> { + throw #() + } + else -> { + R|/| + } + } + + } + public open class A1 : R|kotlin/Any| { + public constructor(x: R|kotlin/String|): R|A1| { + super() + } + + public final val x: R|kotlin/String| = R|/x| + public get(): R|kotlin/String| + + } + public final class B1 : R|A1| { + public constructor(): R|B1| { + super(R|/materialize|()) + } + + } + public open class A2 : R|kotlin/Any| { + public constructor(x: R|kotlin/Int|): R|A2| { + super() + } + + public final val x: R|kotlin/Int| = R|/x| + public get(): R|kotlin/Int| + + } + public final class B2 : R|A2| { + public constructor(): R|B2| { + super(Int(1).R|kotlin/Int.plus|(Int(1))) + } + + } + public open class A3 : R|kotlin/Any| { + public constructor(x: R|kotlin/String|, y: R|kotlin/String| = String()): R|A3| { + super() + } + + public constructor(x: R|kotlin/String|, b: R|kotlin/Boolean| = Boolean(true)): R|A3| { + this(R|/x|, R|/x|) + } + + } + public final class B3_1 : R|A3| { + public constructor(): R|B3_1| { + super(String()) + } + + } + public final class B3_2 : R|A3| { + public constructor(): R|B3_2| { + super(String(), String(asas)) + } + + } + public final class B3_3 : R|A3| { + public constructor(): R|B3_3| { + super(String(), Boolean(true)) + } + + } + public final class B3_4 : R|A3| { + public constructor(): R|B3_4| { + super(String(), Q|kotlin/Unit|) + } + + } diff --git a/compiler/fir/resolve/testData/resolve/delegatingConstructorsAndTypeAliases.kt b/compiler/fir/resolve/testData/resolve/delegatingConstructorsAndTypeAliases.kt new file mode 100644 index 00000000000..79789e1554b --- /dev/null +++ b/compiler/fir/resolve/testData/resolve/delegatingConstructorsAndTypeAliases.kt @@ -0,0 +1,5 @@ +open class Inv(x: T, r: R) + +typealias Alias = Inv> + +class InvImpl : Alias("", Inv("", "")) \ No newline at end of file diff --git a/compiler/fir/resolve/testData/resolve/delegatingConstructorsAndTypeAliases.txt b/compiler/fir/resolve/testData/resolve/delegatingConstructorsAndTypeAliases.txt new file mode 100644 index 00000000000..863e8c28d1d --- /dev/null +++ b/compiler/fir/resolve/testData/resolve/delegatingConstructorsAndTypeAliases.txt @@ -0,0 +1,14 @@ +FILE: delegatingConstructorsAndTypeAliases.kt + public open class Inv : R|kotlin/Any| { + public constructor(x: R|T|, r: R|R|): R|Inv| { + super() + } + + } + public final typealias Alias = R|Inv>| + public final class InvImpl : R|Alias| { + public constructor(): R|InvImpl| { + super|>(String(), R|/Inv.Inv|(String(), String())) + } + + } diff --git a/compiler/fir/resolve/testData/resolve/expresssions/protectedVisibility.kt b/compiler/fir/resolve/testData/resolve/expresssions/protectedVisibility.kt index a705f24d682..2bcc96e899f 100644 --- a/compiler/fir/resolve/testData/resolve/expresssions/protectedVisibility.kt +++ b/compiler/fir/resolve/testData/resolve/expresssions/protectedVisibility.kt @@ -56,7 +56,7 @@ open class Generic(val x: T) { protected open fun foo(): T = x } -class DerivedGeneric : Generic() { +class DerivedGeneric : Generic(1) { override fun foo(): Int { return super.foo() } diff --git a/compiler/fir/resolve/testData/resolve/expresssions/protectedVisibility.txt b/compiler/fir/resolve/testData/resolve/expresssions/protectedVisibility.txt index cd0ae840709..f9bdc7cc744 100644 --- a/compiler/fir/resolve/testData/resolve/expresssions/protectedVisibility.txt +++ b/compiler/fir/resolve/testData/resolve/expresssions/protectedVisibility.txt @@ -97,7 +97,7 @@ FILE: protectedVisibility.kt } public final class DerivedGeneric : R|Generic| { public constructor(): R|DerivedGeneric| { - super|>() + super|>(Int(1)) } public final override fun foo(): R|kotlin/Int| { diff --git a/compiler/fir/resolve/testData/resolve/stdlib/j+k/KJKComplexHierarchyNestedLoop.kt b/compiler/fir/resolve/testData/resolve/stdlib/j+k/KJKComplexHierarchyNestedLoop.kt index cb863d7ced1..fd9ac18f6c4 100644 --- a/compiler/fir/resolve/testData/resolve/stdlib/j+k/KJKComplexHierarchyNestedLoop.kt +++ b/compiler/fir/resolve/testData/resolve/stdlib/j+k/KJKComplexHierarchyNestedLoop.kt @@ -1,5 +1,5 @@ // FILE: K1.kt -class K2: J1() { +class K2: J1() { class Q : Nested() fun bar() { foo() diff --git a/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/FirDiagnosticsTestGenerated.java b/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/FirDiagnosticsTestGenerated.java index 4081fe98d77..4288452759c 100644 --- a/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/FirDiagnosticsTestGenerated.java +++ b/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/FirDiagnosticsTestGenerated.java @@ -53,6 +53,16 @@ public class FirDiagnosticsTestGenerated extends AbstractFirDiagnosticsTest { runTest("compiler/fir/resolve/testData/resolve/delegatedSuperType.kt"); } + @TestMetadata("delegatingConstructorCall.kt") + public void testDelegatingConstructorCall() throws Exception { + runTest("compiler/fir/resolve/testData/resolve/delegatingConstructorCall.kt"); + } + + @TestMetadata("delegatingConstructorsAndTypeAliases.kt") + public void testDelegatingConstructorsAndTypeAliases() throws Exception { + runTest("compiler/fir/resolve/testData/resolve/delegatingConstructorsAndTypeAliases.kt"); + } + @TestMetadata("derivedClass.kt") public void testDerivedClass() throws Exception { runTest("compiler/fir/resolve/testData/resolve/derivedClass.kt"); diff --git a/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/FirResolveBench.kt b/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/FirResolveBench.kt index 3f071f1afc7..260cd381c80 100644 --- a/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/FirResolveBench.kt +++ b/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/FirResolveBench.kt @@ -238,11 +238,7 @@ class FirResolveBench(val withProgress: Boolean) { } override fun visitImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef) { - if (implicitTypeRef is FirResolvedTypeRef) { - visitResolvedTypeRef(implicitTypeRef) - } else { - visitTypeRef(implicitTypeRef) - } + visitTypeRef(implicitTypeRef) } override fun visitResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef) { diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/FirDelegatedConstructorCall.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/FirDelegatedConstructorCall.kt index 1dfe6310f76..72bae37a36f 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/FirDelegatedConstructorCall.kt +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/FirDelegatedConstructorCall.kt @@ -16,18 +16,18 @@ import org.jetbrains.kotlin.fir.visitors.* * DO NOT MODIFY IT MANUALLY */ -abstract class FirDelegatedConstructorCall : FirPureAbstractElement(), FirCall { +abstract class FirDelegatedConstructorCall : FirPureAbstractElement(), FirResolvable, FirCall { abstract override val source: FirSourceElement? + abstract override val calleeReference: FirReference abstract override val annotations: List abstract override val arguments: List abstract val constructedTypeRef: FirTypeRef abstract val isThis: Boolean abstract val isSuper: Boolean - abstract val calleeReference: FirReference override fun accept(visitor: FirVisitor, data: D): R = visitor.visitDelegatedConstructorCall(this, data) - abstract override fun transformArguments(transformer: FirTransformer, data: D): FirDelegatedConstructorCall + abstract override fun transformCalleeReference(transformer: FirTransformer, data: D): FirDelegatedConstructorCall - abstract fun transformCalleeReference(transformer: FirTransformer, data: D): FirDelegatedConstructorCall + abstract override fun transformArguments(transformer: FirTransformer, data: D): FirDelegatedConstructorCall } diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/impl/FirDelegatedConstructorCallImpl.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/impl/FirDelegatedConstructorCallImpl.kt index 6320f36b136..be1838355ed 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/impl/FirDelegatedConstructorCallImpl.kt +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/impl/FirDelegatedConstructorCallImpl.kt @@ -26,28 +26,23 @@ class FirDelegatedConstructorCallImpl( override var constructedTypeRef: FirTypeRef, override val isThis: Boolean ) : FirDelegatedConstructorCall(), FirCallWithArgumentList, FirAbstractAnnotatedElement { + override var calleeReference: FirReference = if (isThis) FirExplicitThisReference(source, null) else FirExplicitSuperReference(source, constructedTypeRef) override val annotations: MutableList = mutableListOf() override val arguments: MutableList = mutableListOf() override val isSuper: Boolean get() = !isThis - override var calleeReference: FirReference = if (isThis) FirExplicitThisReference(source, null) else FirExplicitSuperReference(source, constructedTypeRef) override fun acceptChildren(visitor: FirVisitor, data: D) { + calleeReference.accept(visitor, data) annotations.forEach { it.accept(visitor, data) } arguments.forEach { it.accept(visitor, data) } constructedTypeRef.accept(visitor, data) - calleeReference.accept(visitor, data) } override fun transformChildren(transformer: FirTransformer, data: D): FirDelegatedConstructorCallImpl { + transformCalleeReference(transformer, data) annotations.transformInplace(transformer, data) transformArguments(transformer, data) constructedTypeRef = constructedTypeRef.transformSingle(transformer, data) - transformCalleeReference(transformer, data) - return this - } - - override fun transformArguments(transformer: FirTransformer, data: D): FirDelegatedConstructorCallImpl { - arguments.transformInplace(transformer, data) return this } @@ -55,4 +50,9 @@ class FirDelegatedConstructorCallImpl( calleeReference = calleeReference.transformSingle(transformer, data) return this } + + override fun transformArguments(transformer: FirTransformer, data: D): FirDelegatedConstructorCallImpl { + arguments.transformInplace(transformer, data) + return this + } } diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirTransformer.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirTransformer.kt index b4bee265360..3fe1ef34c2e 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirTransformer.kt +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirTransformer.kt @@ -71,7 +71,6 @@ import org.jetbrains.kotlin.fir.expressions.FirOperatorCall import org.jetbrains.kotlin.fir.expressions.FirTypeOperatorCall import org.jetbrains.kotlin.fir.expressions.FirWhenExpression import org.jetbrains.kotlin.fir.expressions.FirWhenBranch -import org.jetbrains.kotlin.fir.expressions.FirDelegatedConstructorCall import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessWithoutCallee import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccess import org.jetbrains.kotlin.fir.expressions.FirArrayOfCall @@ -81,6 +80,7 @@ import org.jetbrains.kotlin.fir.expressions.FirErrorExpression import org.jetbrains.kotlin.fir.declarations.FirErrorFunction import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessExpression import org.jetbrains.kotlin.fir.expressions.FirFunctionCall +import org.jetbrains.kotlin.fir.expressions.FirDelegatedConstructorCall import org.jetbrains.kotlin.fir.expressions.FirComponentCall import org.jetbrains.kotlin.fir.expressions.FirCallableReferenceAccess import org.jetbrains.kotlin.fir.expressions.FirThisReceiverExpression @@ -388,10 +388,6 @@ abstract class FirTransformer : FirVisitor { - return transformElement(delegatedConstructorCall, data) - } - open fun transformQualifiedAccessWithoutCallee(qualifiedAccessWithoutCallee: FirQualifiedAccessWithoutCallee, data: D): CompositeTransformResult { return transformElement(qualifiedAccessWithoutCallee, data) } @@ -428,6 +424,10 @@ abstract class FirTransformer : FirVisitor { + return transformElement(delegatedConstructorCall, data) + } + open fun transformComponentCall(componentCall: FirComponentCall, data: D): CompositeTransformResult { return transformElement(componentCall, data) } @@ -836,10 +836,6 @@ abstract class FirTransformer : FirVisitor { - return transformDelegatedConstructorCall(delegatedConstructorCall, data) - } - final override fun visitQualifiedAccessWithoutCallee(qualifiedAccessWithoutCallee: FirQualifiedAccessWithoutCallee, data: D): CompositeTransformResult { return transformQualifiedAccessWithoutCallee(qualifiedAccessWithoutCallee, data) } @@ -876,6 +872,10 @@ abstract class FirTransformer : FirVisitor { + return transformDelegatedConstructorCall(delegatedConstructorCall, data) + } + final override fun visitComponentCall(componentCall: FirComponentCall, data: D): CompositeTransformResult { return transformComponentCall(componentCall, data) } diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirVisitor.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirVisitor.kt index aa8b490af6e..ae2363f8880 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirVisitor.kt +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirVisitor.kt @@ -71,7 +71,6 @@ import org.jetbrains.kotlin.fir.expressions.FirOperatorCall import org.jetbrains.kotlin.fir.expressions.FirTypeOperatorCall import org.jetbrains.kotlin.fir.expressions.FirWhenExpression import org.jetbrains.kotlin.fir.expressions.FirWhenBranch -import org.jetbrains.kotlin.fir.expressions.FirDelegatedConstructorCall import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessWithoutCallee import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccess import org.jetbrains.kotlin.fir.expressions.FirArrayOfCall @@ -81,6 +80,7 @@ import org.jetbrains.kotlin.fir.expressions.FirErrorExpression import org.jetbrains.kotlin.fir.declarations.FirErrorFunction import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessExpression import org.jetbrains.kotlin.fir.expressions.FirFunctionCall +import org.jetbrains.kotlin.fir.expressions.FirDelegatedConstructorCall import org.jetbrains.kotlin.fir.expressions.FirComponentCall import org.jetbrains.kotlin.fir.expressions.FirCallableReferenceAccess import org.jetbrains.kotlin.fir.expressions.FirThisReceiverExpression @@ -256,8 +256,6 @@ abstract class FirVisitor { open fun visitWhenBranch(whenBranch: FirWhenBranch, data: D): R = visitElement(whenBranch, data) - open fun visitDelegatedConstructorCall(delegatedConstructorCall: FirDelegatedConstructorCall, data: D): R = visitElement(delegatedConstructorCall, data) - open fun visitQualifiedAccessWithoutCallee(qualifiedAccessWithoutCallee: FirQualifiedAccessWithoutCallee, data: D): R = visitElement(qualifiedAccessWithoutCallee, data) open fun visitQualifiedAccess(qualifiedAccess: FirQualifiedAccess, data: D): R = visitElement(qualifiedAccess, data) @@ -276,6 +274,8 @@ abstract class FirVisitor { open fun visitFunctionCall(functionCall: FirFunctionCall, data: D): R = visitElement(functionCall, data) + open fun visitDelegatedConstructorCall(delegatedConstructorCall: FirDelegatedConstructorCall, data: D): R = visitElement(delegatedConstructorCall, data) + open fun visitComponentCall(componentCall: FirComponentCall, data: D): R = visitElement(componentCall, data) open fun visitCallableReferenceAccess(callableReferenceAccess: FirCallableReferenceAccess, data: D): R = visitElement(callableReferenceAccess, data) diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirVisitorVoid.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirVisitorVoid.kt index 5f1bf39ff55..a94802349b3 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirVisitorVoid.kt +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirVisitorVoid.kt @@ -71,7 +71,6 @@ import org.jetbrains.kotlin.fir.expressions.FirOperatorCall import org.jetbrains.kotlin.fir.expressions.FirTypeOperatorCall import org.jetbrains.kotlin.fir.expressions.FirWhenExpression import org.jetbrains.kotlin.fir.expressions.FirWhenBranch -import org.jetbrains.kotlin.fir.expressions.FirDelegatedConstructorCall import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessWithoutCallee import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccess import org.jetbrains.kotlin.fir.expressions.FirArrayOfCall @@ -81,6 +80,7 @@ import org.jetbrains.kotlin.fir.expressions.FirErrorExpression import org.jetbrains.kotlin.fir.declarations.FirErrorFunction import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessExpression import org.jetbrains.kotlin.fir.expressions.FirFunctionCall +import org.jetbrains.kotlin.fir.expressions.FirDelegatedConstructorCall import org.jetbrains.kotlin.fir.expressions.FirComponentCall import org.jetbrains.kotlin.fir.expressions.FirCallableReferenceAccess import org.jetbrains.kotlin.fir.expressions.FirThisReceiverExpression @@ -386,10 +386,6 @@ abstract class FirVisitorVoid : FirVisitor() { visitElement(whenBranch) } - open fun visitDelegatedConstructorCall(delegatedConstructorCall: FirDelegatedConstructorCall) { - visitElement(delegatedConstructorCall) - } - open fun visitQualifiedAccessWithoutCallee(qualifiedAccessWithoutCallee: FirQualifiedAccessWithoutCallee) { visitElement(qualifiedAccessWithoutCallee) } @@ -426,6 +422,10 @@ abstract class FirVisitorVoid : FirVisitor() { visitElement(functionCall) } + open fun visitDelegatedConstructorCall(delegatedConstructorCall: FirDelegatedConstructorCall) { + visitElement(delegatedConstructorCall) + } + open fun visitComponentCall(componentCall: FirComponentCall) { visitElement(componentCall) } @@ -834,10 +834,6 @@ abstract class FirVisitorVoid : FirVisitor() { visitWhenBranch(whenBranch) } - final override fun visitDelegatedConstructorCall(delegatedConstructorCall: FirDelegatedConstructorCall, data: Nothing?) { - visitDelegatedConstructorCall(delegatedConstructorCall) - } - final override fun visitQualifiedAccessWithoutCallee(qualifiedAccessWithoutCallee: FirQualifiedAccessWithoutCallee, data: Nothing?) { visitQualifiedAccessWithoutCallee(qualifiedAccessWithoutCallee) } @@ -874,6 +870,10 @@ abstract class FirVisitorVoid : FirVisitor() { visitFunctionCall(functionCall) } + final override fun visitDelegatedConstructorCall(delegatedConstructorCall: FirDelegatedConstructorCall, data: Nothing?) { + visitDelegatedConstructorCall(delegatedConstructorCall) + } + final override fun visitComponentCall(componentCall: FirComponentCall, data: Nothing?) { visitComponentCall(componentCall) } diff --git a/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/FirTreeBuilder.kt b/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/FirTreeBuilder.kt index 68643859ef3..fba4eb9d768 100644 --- a/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/FirTreeBuilder.kt +++ b/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/FirTreeBuilder.kt @@ -84,7 +84,6 @@ object FirTreeBuilder : AbstractFirTreeBuilder() { val typeOperatorCall = element("TypeOperatorCall", Expression, expression, call) val whenExpression = element("WhenExpression", Expression, expression, resolvable) val whenBranch = element("WhenBranch", Expression) - val delegatedConstructorCall = element("DelegatedConstructorCall", Expression, call) val qualifiedAccessWithoutCallee = element("QualifiedAccessWithoutCallee", Expression, statement) val qualifiedAccess = element("QualifiedAccess", Expression, qualifiedAccessWithoutCallee, resolvable) @@ -95,6 +94,7 @@ object FirTreeBuilder : AbstractFirTreeBuilder() { val errorFunction = element("ErrorFunction", Declaration, function, diagnosticHolder) val qualifiedAccessExpression = element("QualifiedAccessExpression", Expression, expression, qualifiedAccess) val functionCall = element("FunctionCall", Expression, qualifiedAccessExpression, call) + val delegatedConstructorCall = element("DelegatedConstructorCall", Expression, resolvable, call) val componentCall = element("ComponentCall", Expression, functionCall) val callableReferenceAccess = element("CallableReferenceAccess", Expression, qualifiedAccessExpression) val thisReceiverExpression = element("ThisReceiverExpression", Expression, qualifiedAccessExpression) diff --git a/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/ImplementationConfigurator.kt b/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/ImplementationConfigurator.kt index 92f31a50001..0e92b3c1f73 100644 --- a/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/ImplementationConfigurator.kt +++ b/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/ImplementationConfigurator.kt @@ -575,6 +575,16 @@ object ImplementationConfigurator : AbstractFirTreeImplementationConfigurator() } noImpl(userTypeRef) + +// impl(delegatedConstructorCall) { +// defaultTrue("safe", withGetter = true) +// listOf("dispatchReceiver", "extensionReceiver", "explicitReceiver").forEach { +// default(it) { +// value = "FirNoReceiverExpression" +// withGetter = true +// } +// } +// } } private fun findImplementationsWithAnnotations(implementationPredicate: (Implementation) -> Boolean): Collection { diff --git a/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/NodeConfigurator.kt b/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/NodeConfigurator.kt index b0e819e8929..b3bd4cb9b2f 100644 --- a/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/NodeConfigurator.kt +++ b/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/NodeConfigurator.kt @@ -324,7 +324,6 @@ object NodeConfigurator : AbstractFieldConfigurator() { delegatedConstructorCall.configure { +field("constructedTypeRef", typeRef) generateBooleanFields("this", "super") - +calleeReference.withTransform() } valueParameter.configure { diff --git a/compiler/testData/ir/irText/expressions/objectReferenceInClosureInSuperConstructorCall.fir.txt b/compiler/testData/ir/irText/expressions/objectReferenceInClosureInSuperConstructorCall.fir.txt index 8dc2692ff0f..1430a1b49fe 100644 --- a/compiler/testData/ir/irText/expressions/objectReferenceInClosureInSuperConstructorCall.fir.txt +++ b/compiler/testData/ir/irText/expressions/objectReferenceInClosureInSuperConstructorCall.fir.txt @@ -35,10 +35,10 @@ FILE fqName: fileName:/objectReferenceInClosureInSuperConstructorCall.kt CONSTRUCTOR visibility:private <> () returnType:.Test [primary] BLOCK_BODY DELEGATING_CONSTRUCTOR_CALL 'public constructor (lambda: kotlin.Function0) [primary] declared in .Base' - lambda: FUN_EXPR type=IrErrorType origin=LAMBDA - FUN LOCAL_FUNCTION_FOR_LAMBDA name: visibility:local modality:FINAL <> () returnType:IrErrorType + lambda: FUN_EXPR type=kotlin.Function0 origin=LAMBDA + FUN LOCAL_FUNCTION_FOR_LAMBDA name: visibility:local modality:FINAL <> () returnType:kotlin.Any BLOCK_BODY - ERROR_CALL 'Unresolved reference: Test#' type=IrErrorType + GET_OBJECT 'CLASS OBJECT name:Test modality:FINAL visibility:public superTypes:[.Base]' type=.Test INSTANCE_INITIALIZER_CALL classDescriptor='CLASS OBJECT name:Test modality:FINAL visibility:public superTypes:[.Base]' PROPERTY FAKE_OVERRIDE name:lambda visibility:public modality:FINAL [fake_override,val] FUN FAKE_OVERRIDE name: visibility:public modality:FINAL <> ($this:.Test) returnType:kotlin.Function0 [fake_override]