[FIR] Support imported callable from object properly #KT-35730 Fixed

2020-07-08 12:21:51 +03:00
parent 6b964cb61d
commit fbbf4e06ba
15 changed files with 218 additions and 28 deletions
@@ -30,6 +30,6 @@ FILE: importedReceiver.kt
        (Q|My|, String()).R|/My.bar|<R|kotlin/String|>()
        Q|My|.R|/My.baz|()
        (Q|My|, Boolean(true)).R|/My.gau|()
-        R|/Your.wat|()
+        Q|My|.R|/Your.wat|()
        (Q|My|, Boolean(false)).R|FakeOverride</My.watwat: R|kotlin/Unit|>|<R|kotlin/Boolean|>()
    }
@@ -11,5 +11,5 @@ FILE: objectOverrideCallViaImport.kt

    }
    public final fun test(): R|kotlin/Unit| {
-        R|/Base.foo|()
+        Q|Derived|.R|/Base.foo|()
    }
@@ -1082,6 +1082,11 @@ public class Fir2IrTextTestGenerated extends AbstractFir2IrTextTest {
            runTest("compiler/testData/ir/irText/expressions/kt30796.kt");
        }

+        @TestMetadata("kt35730.kt")
+        public void testKt35730() throws Exception {
+            runTest("compiler/testData/ir/irText/expressions/kt35730.kt");
+        }
+
        @TestMetadata("kt36956.kt")
        public void testKt36956() throws Exception {
            runTest("compiler/testData/ir/irText/expressions/kt36956.kt");
@@ -5,9 +5,9 @@

 package org.jetbrains.kotlin.fir.resolve.calls.tower

-import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirConstructor
+import org.jetbrains.kotlin.fir.declarations.FirDeclarationOrigin
 import org.jetbrains.kotlin.fir.declarations.isInner
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.expressions.builder.buildResolvedQualifier
@@ -20,7 +20,6 @@ import org.jetbrains.kotlin.fir.resolve.typeForQualifier
 import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.fir.scopes.ProcessorAction
 import org.jetbrains.kotlin.fir.scopes.impl.FirAbstractImportingScope
-import org.jetbrains.kotlin.fir.scopes.impl.FirExplicitSimpleImportingScope
 import org.jetbrains.kotlin.fir.scopes.processClassifiersByName
 import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.*
@@ -204,13 +203,11 @@ class ScopeTowerLevel(
            else -> true
        }

-    private fun dispatchReceiverValue(scope: FirScope, candidate: FirCallableSymbol<*>): ReceiverValue? {
+    private fun dispatchReceiverValue(candidate: FirCallableSymbol<*>): ReceiverValue? {
        val holderId = candidate.callableId.classId
-        if (holderId != null && scope is FirExplicitSimpleImportingScope) {
+        if (holderId != null && candidate.fir.origin == FirDeclarationOrigin.ImportedFromObject) {
            val symbol = session.firSymbolProvider.getClassLikeSymbolByFqName(holderId)
-            if (symbol is FirRegularClassSymbol &&
-                symbol.fir.classKind.let { it == ClassKind.OBJECT || it == ClassKind.ENUM_ENTRY }
-            ) {
+            if (symbol is FirRegularClassSymbol) {
                val resolvedQualifier = buildResolvedQualifier {
                    packageFqName = holderId.packageFqName
                    relativeClassFqName = holderId.relativeClassName
@@ -234,6 +231,23 @@ class ScopeTowerLevel(
        }
    }

+    private fun <T : AbstractFirBasedSymbol<*>> consumeCallableCandidate(
+        candidate: FirCallableSymbol<*>,
+        processor: TowerScopeLevel.TowerScopeLevelProcessor<T>
+    ) {
+        if (candidate.hasConsistentReceivers(extensionReceiver)) {
+            val dispatchReceiverValue = dispatchReceiverValue(candidate)
+            val unwrappedCandidate = if (candidate.fir.origin == FirDeclarationOrigin.ImportedFromObject) {
+                candidate.overriddenSymbol!!
+            } else candidate
+            @Suppress("UNCHECKED_CAST")
+            processor.consumeCandidate(
+                unwrappedCandidate as T, dispatchReceiverValue,
+                implicitExtensionReceiverValue = extensionReceiver as? ImplicitReceiverValue<*>
+            )
+        }
+    }
+
    override fun <T : AbstractFirBasedSymbol<*>> processElementsByName(
        token: TowerScopeLevel.Token<T>,
        name: Name,
@@ -244,13 +258,7 @@ class ScopeTowerLevel(
        when (token) {
            TowerScopeLevel.Token.Properties -> scope.processPropertiesByName(name) { candidate ->
                empty = false
-                if (candidate.hasConsistentReceivers(extensionReceiver)) {
-                    val dispatchReceiverValue = dispatchReceiverValue(scope, candidate)
-                    processor.consumeCandidate(
-                        candidate as T, dispatchReceiverValue,
-                        implicitExtensionReceiverValue = extensionReceiver as? ImplicitReceiverValue<*>
-                    )
-                }
+                consumeCallableCandidate(candidate, processor)
            }
            TowerScopeLevel.Token.Functions -> scope.processFunctionsAndConstructorsByName(
                name,
@@ -259,13 +267,7 @@ class ScopeTowerLevel(
                includeInnerConstructors = includeInnerConstructors
            ) { candidate ->
                empty = false
-                if (candidate.hasConsistentReceivers(extensionReceiver)) {
-                    val dispatchReceiverValue = dispatchReceiverValue(scope, candidate)
-                    processor.consumeCandidate(
-                        candidate as T, dispatchReceiverValue,
-                        implicitExtensionReceiverValue = extensionReceiver as? ImplicitReceiverValue<*>
-                    )
-                }
+                consumeCallableCandidate(candidate, processor)
            }
            TowerScopeLevel.Token.Objects -> scope.processClassifiersByName(name) {
                empty = false
@@ -37,7 +37,7 @@ abstract class FirAbstractImportingScope(
            val firClass = (symbol as FirClassSymbol<*>).fir

            return if (firClass.classKind == ClassKind.OBJECT)
-                firClass.unsubstitutedScope(session, scopeSession)
+                FirObjectImportedCallableScope(classId, firClass.unsubstitutedScope(session, scopeSession))
            else
                firClass.scopeProvider.getStaticScope(firClass, session, scopeSession)
        }
@@ -0,0 +1,74 @@
+/*
+ * 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.scopes.impl
+
+import org.jetbrains.kotlin.fir.declarations.FirDeclarationOrigin
+import org.jetbrains.kotlin.fir.declarations.builder.buildProperty
+import org.jetbrains.kotlin.fir.declarations.builder.buildSimpleFunction
+import org.jetbrains.kotlin.fir.scopes.FirScope
+import org.jetbrains.kotlin.fir.symbols.CallableId
+import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol
+import org.jetbrains.kotlin.name.ClassId
+import org.jetbrains.kotlin.name.Name
+
+class FirObjectImportedCallableScope(
+    private val importedClassId: ClassId,
+    private val objectUseSiteScope: FirScope
+) : FirScope() {
+    override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> Unit) {
+        objectUseSiteScope.processFunctionsByName(name) wrapper@{ symbol ->
+            if (symbol !is FirNamedFunctionSymbol) {
+                processor(symbol)
+                return@wrapper
+            }
+            val function = symbol.fir
+            val syntheticFunction = buildSimpleFunction {
+                source = function.source
+                session = function.session
+                origin = FirDeclarationOrigin.ImportedFromObject
+                returnTypeRef = function.returnTypeRef
+                receiverTypeRef = function.receiverTypeRef
+                this.name = function.name
+                status = function.status
+                this.symbol = FirNamedFunctionSymbol(CallableId(importedClassId, name), overriddenSymbol = symbol)
+                resolvePhase = function.resolvePhase
+                typeParameters.addAll(function.typeParameters)
+                valueParameters.addAll(function.valueParameters)
+                annotations.addAll(function.annotations)
+            }
+            processor(syntheticFunction.symbol)
+        }
+    }
+
+    override fun processPropertiesByName(name: Name, processor: (FirVariableSymbol<*>) -> Unit) {
+        objectUseSiteScope.processPropertiesByName(name) wrapper@{ symbol ->
+            if (symbol !is FirPropertySymbol) {
+                processor(symbol)
+                return@wrapper
+            }
+            val property = symbol.fir
+            val syntheticFunction = buildProperty {
+                source = property.source
+                session = property.session
+                origin = FirDeclarationOrigin.ImportedFromObject
+                returnTypeRef = property.returnTypeRef
+                receiverTypeRef = property.receiverTypeRef
+                this.name = property.name
+                status = property.status
+                isVar = property.isVar
+                isLocal = property.isLocal
+                this.symbol = FirPropertySymbol(CallableId(importedClassId, name), overriddenSymbol = symbol)
+                resolvePhase = property.resolvePhase
+                typeParameters.addAll(property.typeParameters)
+                annotations.addAll(property.annotations)
+            }
+            processor(syntheticFunction.symbol)
+        }
+    }
+}
@@ -13,6 +13,7 @@ sealed class FirDeclarationOrigin {
    object SamConstructor : FirDeclarationOrigin()
    object FakeOverride : FirDeclarationOrigin()
    object Enhancement : FirDeclarationOrigin()
+    object ImportedFromObject : FirDeclarationOrigin()

    class Plugin(val key: FirPluginKey) : FirDeclarationOrigin()
 }