azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

IC: Implement expect/actual tracking

Browse Source 
fixes NewMultiplatformIT.testIncrementalCompilation
also #KT-61590 fixed
This commit is contained in:
Ilya Chernikov
2023-09-14 17:26:32 +02:00
committed by Space Team
parent 9ed23a7f07
commit e5ee364419
15 changed files with 117 additions and 46 deletions
Download Patch File Download Diff File Expand all files Collapse all files
analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirCompilerFacility.kt
+3 -2
View File
@@ -141,8 +141,9 @@ internal class KtFirCompilerFacility(
effectiveConfiguration.languageVersionSettings,
diagnosticsReporter,
linkViaSignatures = false,
effectiveConfiguration[CommonConfigurationKeys.EVALUATED_CONST_TRACKER] ?: EvaluatedConstTracker.create(),
effectiveConfiguration[CommonConfigurationKeys.INLINE_CONST_TRACKER],
evaluatedConstTracker = effectiveConfiguration[CommonConfigurationKeys.EVALUATED_CONST_TRACKER] ?: EvaluatedConstTracker.create(),
inlineConstTracker = effectiveConfiguration[CommonConfigurationKeys.INLINE_CONST_TRACKER],
expectActualTracker = effectiveConfiguration[CommonConfigurationKeys.EXPECT_ACTUAL_TRACKER],
allowNonCachedDeclarations = true,
useIrFakeOverrideBuilder = effectiveConfiguration.getBoolean(CommonConfigurationKeys.USE_IR_FAKE_OVERRIDE_BUILDER),
)
compiler/cli/cli-js/src/org/jetbrains/kotlin/cli/js/klib/compilerPipeline.kt
+1
View File
@@ -240,6 +240,7 @@ fun transformFirToIr(
evaluatedConstTracker = moduleStructure.compilerConfiguration
.putIfAbsent(CommonConfigurationKeys.EVALUATED_CONST_TRACKER, EvaluatedConstTracker.create()),
inlineConstTracker = null,
expectActualTracker = moduleStructure.compilerConfiguration[CommonConfigurationKeys.EXPECT_ACTUAL_TRACKER],
allowNonCachedDeclarations = false,
useIrFakeOverrideBuilder =
moduleStructure.compilerConfiguration.getBoolean(CommonConfigurationKeys.USE_IR_FAKE_OVERRIDE_BUILDER),
compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/FirKotlinToJvmBytecodeCompiler.kt
+1
View File
@@ -243,6 +243,7 @@ object FirKotlinToJvmBytecodeCompiler {
evaluatedConstTracker = configuration
.putIfAbsent(CommonConfigurationKeys.EVALUATED_CONST_TRACKER, EvaluatedConstTracker.create()),
inlineConstTracker = configuration[CommonConfigurationKeys.INLINE_CONST_TRACKER],
expectActualTracker = configuration[CommonConfigurationKeys.EXPECT_ACTUAL_TRACKER],
allowNonCachedDeclarations = false,
useIrFakeOverrideBuilder = configuration.getBoolean(CommonConfigurationKeys.USE_IR_FAKE_OVERRIDE_BUILDER),
)
compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/pipeline/compilerPipeline.kt
+1
View File
@@ -184,6 +184,7 @@ fun convertAnalyzedFirToIr(
evaluatedConstTracker = input.configuration
.putIfAbsent(CommonConfigurationKeys.EVALUATED_CONST_TRACKER, EvaluatedConstTracker.create()),
inlineConstTracker = input.configuration[CommonConfigurationKeys.INLINE_CONST_TRACKER],
expectActualTracker = input.configuration[CommonConfigurationKeys.EXPECT_ACTUAL_TRACKER],
allowNonCachedDeclarations = false,
useIrFakeOverrideBuilder = input.configuration.getBoolean(CommonConfigurationKeys.USE_IR_FAKE_OVERRIDE_BUILDER),
)
compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/pipeline/convertToIr.kt
+2 -2
View File
@@ -19,7 +19,6 @@ import org.jetbrains.kotlin.fir.backend.jvm.Fir2IrJvmSpecialAnnotationSymbolProv
import org.jetbrains.kotlin.fir.backend.jvm.FirJvmKotlinMangler
import org.jetbrains.kotlin.fir.backend.jvm.FirJvmVisibilityConverter
import org.jetbrains.kotlin.fir.declarations.FirFile
import org.jetbrains.kotlin.fir.moduleData
import org.jetbrains.kotlin.fir.resolve.ScopeSession
import org.jetbrains.kotlin.ir.IrBuiltIns
import org.jetbrains.kotlin.ir.backend.jvm.serialization.JvmDescriptorMangler
@@ -171,7 +170,8 @@ fun FirResult.convertToIrAndActualize(
commonMemberStorage.symbolTable,
irMangler,
Fir2IrConverter.friendModulesMap(outputs.last().session),
fir2IrConfiguration.useIrFakeOverrideBuilder
fir2IrConfiguration.useIrFakeOverrideBuilder,
fir2IrConfiguration.expectActualTracker
)
}
}
compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrConfiguration.kt
+2
View File
@@ -19,6 +19,7 @@ package org.jetbrains.kotlin.fir.backend
import org.jetbrains.kotlin.config.LanguageVersionSettings
import org.jetbrains.kotlin.constant.EvaluatedConstTracker
import org.jetbrains.kotlin.diagnostics.DiagnosticReporter
import org.jetbrains.kotlin.incremental.components.ExpectActualTracker
import org.jetbrains.kotlin.incremental.components.InlineConstTracker
/**
@@ -36,6 +37,7 @@ data class Fir2IrConfiguration(
val linkViaSignatures: Boolean,
val evaluatedConstTracker: EvaluatedConstTracker,
val inlineConstTracker: InlineConstTracker?,
val expectActualTracker: ExpectActualTracker?,
val allowNonCachedDeclarations: Boolean,
val useIrFakeOverrideBuilder: Boolean,
)
compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/IncrementalFirJvmCompilerRunner.kt
+1
View File
@@ -278,6 +278,7 @@ open class IncrementalFirJvmCompilerRunner(
evaluatedConstTracker = configuration
.putIfAbsent(CommonConfigurationKeys.EVALUATED_CONST_TRACKER, EvaluatedConstTracker.create()),
inlineConstTracker = configuration[CommonConfigurationKeys.INLINE_CONST_TRACKER],
expectActualTracker = configuration[CommonConfigurationKeys.EXPECT_ACTUAL_TRACKER],
allowNonCachedDeclarations = false,
useIrFakeOverrideBuilder = configuration.getBoolean(CommonConfigurationKeys.USE_IR_FAKE_OVERRIDE_BUILDER),
)
compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/actualizer/ExpectActualCollector.kt
+95 -40
View File
@@ -6,21 +6,23 @@
package org.jetbrains.kotlin.backend.common.actualizer
import org.jetbrains.kotlin.KtDiagnosticReporterWithImplicitIrBasedContext
import org.jetbrains.kotlin.incremental.components.ExpectActualTracker
import org.jetbrains.kotlin.ir.IrElement
import org.jetbrains.kotlin.ir.PsiIrFileEntry
import org.jetbrains.kotlin.ir.declarations.*
import org.jetbrains.kotlin.ir.symbols.*
import org.jetbrains.kotlin.ir.types.IrTypeSystemContext
import org.jetbrains.kotlin.ir.types.classifierOrFail
import org.jetbrains.kotlin.ir.util.callableId
import org.jetbrains.kotlin.ir.util.classIdOrFail
import org.jetbrains.kotlin.ir.visitors.IrElementVisitorVoid
import org.jetbrains.kotlin.ir.visitors.acceptChildrenVoid
import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
import org.jetbrains.kotlin.mpp.DeclarationSymbolMarker
import org.jetbrains.kotlin.mpp.RegularClassSymbolMarker
import org.jetbrains.kotlin.name.CallableId
import org.jetbrains.kotlin.name.ClassId
import org.jetbrains.kotlin.resolve.calls.mpp.AbstractExpectActualCompatibilityChecker
import org.jetbrains.kotlin.resolve.multiplatform.ExpectActualCompatibility
import java.io.File
/**
* This class is used to collect mapping between all expect and actuals declarations, which are declared in passed module fragments
@@ -41,6 +43,7 @@ internal class ExpectActualCollector(
private val dependentFragments: List<IrModuleFragment>,
private val typeSystemContext: IrTypeSystemContext,
private val diagnosticsReporter: KtDiagnosticReporterWithImplicitIrBasedContext,
private val expectActualTracker: ExpectActualTracker?,
) {
data class Result(val expectToActualMap: MutableMap<IrSymbol, IrSymbol>, val classActualizationInfo: ClassActualizationInfo)
@@ -61,12 +64,16 @@ internal class ExpectActualCollector(
destination: MutableMap<IrSymbol, IrSymbol>,
classActualizationInfo: ClassActualizationInfo,
) {
val linkCollector = ExpectActualLinkCollector(destination, classActualizationInfo, typeSystemContext, diagnosticsReporter)
dependentFragments.forEach { linkCollector.visitModuleFragment(it) }
val linkCollector = ExpectActualLinkCollector()
val linkCollectorContext =
ExpectActualLinkCollector.MatchingContext(
typeSystemContext, destination, diagnosticsReporter, expectActualTracker, classActualizationInfo, null
)
dependentFragments.forEach { linkCollector.visitModuleFragment(it, linkCollectorContext) }
// It doesn't make sense to link expects from the last module because actuals always should be located in another module
// Thus relevant actuals are always missing for the last module
// But the collector should be run anyway to detect and report "hanging" expect declarations
linkCollector.visitModuleFragment(mainFragment)
linkCollector.visitModuleFragment(mainFragment, linkCollectorContext)
}
}
@@ -75,7 +82,8 @@ internal data class ClassActualizationInfo(
val actualClasses: Map<ClassId, IrClassSymbol>,
// mapping from classId to actual typealias
val actualTypeAliases: Map<ClassId, IrTypeAliasSymbol>,
val actualTopLevels: Map<CallableId, List<IrDeclarationWithName>>,
val actualTopLevels: Map<CallableId, List<IrSymbol>>,
val actualSymbolsToFile: Map<IrSymbol, IrFile?>,
) {
fun getActualWithoutExpansion(classId: ClassId): IrSymbol? {
return actualTypeAliases[classId] ?: actualClasses[classId]
@@ -94,16 +102,19 @@ private class ActualDeclarationsCollector {
return ClassActualizationInfo(
collector.actualClasses,
collector.actualTypeAliasesWithoutExpansion,
collector.actualTopLevels
collector.actualTopLevels,
collector.actualSymbolsToFile
)
}
}
private val actualClasses: MutableMap<ClassId, IrClassSymbol> = mutableMapOf()
private val actualTypeAliasesWithoutExpansion: MutableMap<ClassId, IrTypeAliasSymbol> = mutableMapOf()
private val actualTopLevels: MutableMap<CallableId, MutableList<IrDeclarationWithName>> = mutableMapOf()
private val actualTopLevels: MutableMap<CallableId, MutableList<IrSymbol>> = mutableMapOf()
private val actualSymbolsToFile: MutableMap<IrSymbol, IrFile?> = mutableMapOf()
private val visitedActualClasses = mutableSetOf<IrClass>()
private var currentFile: IrFile? = null
private fun collect(element: IrElement) {
when (element) {
@@ -112,6 +123,12 @@ private class ActualDeclarationsCollector {
collect(file)
}
}
is IrFile -> {
currentFile = element
for (declaration in element.declarations) {
collect(declaration)
}
}
is IrTypeAlias -> {
if (!element.isActual) return
@@ -120,6 +137,8 @@ private class ActualDeclarationsCollector {
actualClasses[classId] = expandedTypeSymbol
actualTypeAliasesWithoutExpansion[classId] = element.symbol
actualSymbolsToFile[expandedTypeSymbol] = currentFile
actualSymbolsToFile[element.symbol] = currentFile
collect(expandedTypeSymbol.owner)
}
@@ -127,6 +146,7 @@ private class ActualDeclarationsCollector {
if (element.isExpect || !visitedActualClasses.add(element)) return
actualClasses[element.classIdOrFail] = element.symbol
actualSymbolsToFile[element.symbol] = currentFile
for (declaration in element.declarations) {
collect(declaration)
}
@@ -154,65 +174,86 @@ private class ActualDeclarationsCollector {
if (callableId.classId == null) {
actualTopLevels
.getOrPut(callableId) { mutableListOf() }
.add(callableDeclaration)
.add(callableDeclaration.symbol)
actualSymbolsToFile[callableDeclaration.symbol] = currentFile
}
}
}
private class ExpectActualLinkCollector(
private val destination: MutableMap<IrSymbol, IrSymbol>,
private val classActualizationInfo: ClassActualizationInfo,
typeSystemContext: IrTypeSystemContext,
private val diagnosticsReporter: KtDiagnosticReporterWithImplicitIrBasedContext,
) : IrElementVisitorVoid {
private val context = MatchingContext(typeSystemContext)
private class ExpectActualLinkCollector : IrElementVisitor<Unit, ExpectActualLinkCollector.MatchingContext> {
override fun visitFunction(declaration: IrFunction) {
override fun visitFile(declaration: IrFile, data: MatchingContext) {
super.visitFile(declaration, data.withNewCurrentFile(declaration))
}
override fun visitFunction(declaration: IrFunction, data: MatchingContext) {
if (declaration.isExpect) {
matchExpectCallable(declaration, declaration.callableId)
matchExpectCallable(declaration, declaration.callableId, data)
}
}
override fun visitProperty(declaration: IrProperty) {
override fun visitProperty(declaration: IrProperty, data: MatchingContext) {
if (declaration.isExpect) {
matchExpectCallable(declaration, declaration.callableId)
matchExpectCallable(declaration, declaration.callableId, data)
}
}
private fun matchExpectCallable(declaration: IrDeclarationWithName, callableId: CallableId) {
val actualSymbols = classActualizationInfo.actualTopLevels[callableId]?.map { it.symbol }.orEmpty()
matchExpectDeclaration(declaration.symbol, actualSymbols)
}
override fun visitClass(declaration: IrClass) {
if (!declaration.isExpect) return
val classId = declaration.classIdOrFail
val expectClassSymbol = declaration.symbol
val actualClassLikeSymbol = classActualizationInfo.getActualWithoutExpansion(classId)
matchExpectDeclaration(expectClassSymbol, listOfNotNull(actualClassLikeSymbol))
}
private fun matchExpectDeclaration(expectSymbol: IrSymbol, actualSymbols: List<IrSymbol>) {
AbstractExpectActualCompatibilityChecker.matchSingleExpectTopLevelDeclarationAgainstPotentialActuals(
expectSymbol,
actualSymbols,
private fun matchExpectCallable(declaration: IrDeclarationWithName, callableId: CallableId, context: MatchingContext) {
matchExpectDeclaration(
declaration.symbol,
context.classActualizationInfo.actualTopLevels[callableId].orEmpty(),
context
)
}
override fun visitElement(element: IrElement) {
element.acceptChildrenVoid(this)
override fun visitClass(declaration: IrClass, data: MatchingContext) {
if (!declaration.isExpect) return
val classId = declaration.classIdOrFail
val expectClassSymbol = declaration.symbol
val actualClassLikeSymbol = data.classActualizationInfo.getActualWithoutExpansion(classId)
matchExpectDeclaration(expectClassSymbol, listOfNotNull(actualClassLikeSymbol), data)
}
private inner class MatchingContext(
private fun matchExpectDeclaration(
expectSymbol: IrSymbol,
actualSymbols: List<IrSymbol>,
context: MatchingContext
) {
AbstractExpectActualCompatibilityChecker.matchSingleExpectTopLevelDeclarationAgainstPotentialActuals(
expectSymbol,
actualSymbols,
context,
)
}
override fun visitElement(element: IrElement, data: MatchingContext) {
element.acceptChildren(this, data)
}
class MatchingContext(
typeSystemContext: IrTypeSystemContext,
private val destination: MutableMap<IrSymbol, IrSymbol>,
private val diagnosticsReporter: KtDiagnosticReporterWithImplicitIrBasedContext,
private val expectActualTracker: ExpectActualTracker?,
internal val classActualizationInfo: ClassActualizationInfo,
private val currentExpectFile: IrFile?,
) : IrExpectActualMatchingContext(typeSystemContext, classActualizationInfo.actualClasses) {
private val currentExpectIoFile by lazy(LazyThreadSafetyMode.PUBLICATION) { currentExpectFile?.toIoFile() }
fun withNewCurrentFile(newCurrentFile: IrFile) =
MatchingContext(
typeContext, destination, diagnosticsReporter, expectActualTracker, classActualizationInfo, newCurrentFile
)
override fun onMatchedClasses(expectClassSymbol: IrClassSymbol, actualClassSymbol: IrClassSymbol) {
destination[expectClassSymbol] = actualClassSymbol
expectActualTracker?.reportWithCurrentFile(actualClassSymbol)
recordActualForExpectDeclaration(expectClassSymbol, actualClassSymbol, destination)
}
override fun onMatchedCallables(expectSymbol: IrSymbol, actualSymbol: IrSymbol) {
expectActualTracker?.reportWithCurrentFile(actualSymbol)
recordActualForExpectDeclaration(expectSymbol, actualSymbol, destination)
}
@@ -233,5 +274,19 @@ private class ExpectActualLinkCollector(
}
}
}
private fun ExpectActualTracker.reportWithCurrentFile(actualSymbol: IrSymbol) {
if (currentExpectFile != null) {
val actualIoFile = classActualizationInfo.actualSymbolsToFile[actualSymbol]?.toIoFile()
if (actualIoFile != null) {
report(currentExpectIoFile!!, actualIoFile)
}
}
}
}
}
private fun IrFile.toIoFile(): File? = when (val fe = fileEntry) {
is PsiIrFileEntry -> fe.psiFile.virtualFile.let { it.fileSystem.getNioPath(it)?.toFile() }
else -> File(fileEntry.name).takeIf { it.exists() }
}
compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/actualizer/IrActualizer.kt
+5 -2
View File
@@ -9,6 +9,7 @@ import org.jetbrains.kotlin.KtDiagnosticReporterWithImplicitIrBasedContext
import org.jetbrains.kotlin.config.LanguageFeature
import org.jetbrains.kotlin.config.LanguageVersionSettings
import org.jetbrains.kotlin.diagnostics.DiagnosticReporter
import org.jetbrains.kotlin.incremental.components.ExpectActualTracker
import org.jetbrains.kotlin.ir.declarations.*
import org.jetbrains.kotlin.ir.symbols.IrSymbol
import org.jetbrains.kotlin.ir.types.IrTypeSystemContext
@@ -27,7 +28,8 @@ object IrActualizer {
mangler: KotlinMangler.IrMangler,
// TODO: drop this argument in favor of using [IrModuleDescriptor::shouldSeeInternalsOf] in FakeOverrideBuilder KT-61384
friendModules: Map<String, List<String>>,
useIrFakeOverrideBuilder: Boolean
useIrFakeOverrideBuilder: Boolean,
expectActualTracker: ExpectActualTracker?
): IrActualizedResult {
val ktDiagnosticReporter = KtDiagnosticReporterWithImplicitIrBasedContext(diagnosticReporter, languageVersionSettings)
@@ -37,7 +39,8 @@ object IrActualizer {
mainFragment,
dependentFragments,
typeSystemContext,
ktDiagnosticReporter
ktDiagnosticReporter,
expectActualTracker
).collect()
if (languageVersionSettings.supportsFeature(LanguageFeature.MultiplatformRestrictions)) {
IrExpectActualAnnotationMatchingChecker(expectActualMap, actualDeclarations, typeSystemContext, ktDiagnosticReporter).check()
compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/ir/IrActualizerAndPluginsFacade.kt
+1
View File
@@ -40,6 +40,7 @@ class IrActualizerAndPluginsFacade(
inputArtifact.irMangler,
mapOf(module.name to module.friendDependencies.map { it.moduleName }),
useIrFakeOverrideBuilder = CodegenTestDirectives.ENABLE_IR_FAKE_OVERRIDE_GENERATION in module.directives,
expectActualTracker = null,
)
inputArtifact.irActualizerResult = result
}
compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/Fir2IrJsResultsConverter.kt
+1
View File
@@ -168,6 +168,7 @@ fun ModuleCompilerAnalyzedOutput.convertToJsIr(
evaluatedConstTracker = configuration
.putIfAbsent(CommonConfigurationKeys.EVALUATED_CONST_TRACKER, EvaluatedConstTracker.create()),
inlineConstTracker = null,
expectActualTracker = configuration[CommonConfigurationKeys.EXPECT_ACTUAL_TRACKER],
allowNonCachedDeclarations = false,
useIrFakeOverrideBuilder = module.shouldUseIrFakeOverrideBuilderInConvertToIr()
)
compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/Fir2IrJvmResultsConverter.kt
+1
View File
@@ -105,6 +105,7 @@ class Fir2IrJvmResultsConverter(
evaluatedConstTracker = compilerConfiguration
.putIfAbsent(CommonConfigurationKeys.EVALUATED_CONST_TRACKER, EvaluatedConstTracker.create()),
inlineConstTracker = compilerConfiguration[CommonConfigurationKeys.INLINE_CONST_TRACKER],
expectActualTracker = compilerConfiguration[CommonConfigurationKeys.EXPECT_ACTUAL_TRACKER],
allowNonCachedDeclarations = false,
useIrFakeOverrideBuilder = module.shouldUseIrFakeOverrideBuilderInConvertToIr(),
)
compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/Fir2IrWasmResultsConverter.kt
+1
View File
@@ -167,6 +167,7 @@ fun ModuleCompilerAnalyzedOutput.convertToWasmIr(
evaluatedConstTracker = configuration
.putIfAbsent(CommonConfigurationKeys.EVALUATED_CONST_TRACKER, EvaluatedConstTracker.create()),
inlineConstTracker = null,
expectActualTracker = configuration[CommonConfigurationKeys.EXPECT_ACTUAL_TRACKER],
allowNonCachedDeclarations = false,
useIrFakeOverrideBuilder = module.shouldUseIrFakeOverrideBuilderInConvertToIr(),
)
compiler/tests-compiler-utils/tests/org/jetbrains/kotlin/codegen/GenerationUtils.kt
+1
View File
@@ -137,6 +137,7 @@ object GenerationUtils {
evaluatedConstTracker = configuration
.putIfAbsent(CommonConfigurationKeys.EVALUATED_CONST_TRACKER, EvaluatedConstTracker.create()),
inlineConstTracker = configuration[CommonConfigurationKeys.INLINE_CONST_TRACKER],
expectActualTracker = configuration[CommonConfigurationKeys.EXPECT_ACTUAL_TRACKER],
allowNonCachedDeclarations = false,
useIrFakeOverrideBuilder = configuration.getBoolean(CommonConfigurationKeys.USE_IR_FAKE_OVERRIDE_BUILDER),
)
kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/Fir2Ir.kt
+1
View File
@@ -80,6 +80,7 @@ internal fun PhaseContext.fir2Ir(
evaluatedConstTracker = configuration
.putIfAbsent(CommonConfigurationKeys.EVALUATED_CONST_TRACKER, EvaluatedConstTracker.create()),
inlineConstTracker = null,
expectActualTracker = configuration[CommonConfigurationKeys.EXPECT_ACTUAL_TRACKER],
allowNonCachedDeclarations = false,
useIrFakeOverrideBuilder = configuration.getBoolean(CommonConfigurationKeys.USE_IR_FAKE_OVERRIDE_BUILDER),
)