diff --git a/analysis/analysis-api-fir/analysis-api-fir-generator/src/org/jetbrains/kotlin/analysis/api/fir/generator/ArgumentsConverterGenerator.kt b/analysis/analysis-api-fir/analysis-api-fir-generator/src/org/jetbrains/kotlin/analysis/api/fir/generator/ArgumentsConverterGenerator.kt new file mode 100644 index 00000000000..6519ea7846e --- /dev/null +++ b/analysis/analysis-api-fir/analysis-api-fir-generator/src/org/jetbrains/kotlin/analysis/api/fir/generator/ArgumentsConverterGenerator.kt @@ -0,0 +1,96 @@ +/* + * Copyright 2010-2022 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.analysis.api.fir.generator + +import org.jetbrains.kotlin.fir.checkers.generator.printImports +import org.jetbrains.kotlin.fir.tree.generator.printer.printCopyright +import org.jetbrains.kotlin.fir.tree.generator.printer.printGeneratedMessage +import org.jetbrains.kotlin.fir.tree.generator.util.writeToFileUsingSmartPrinterIfFileContentChanged +import org.jetbrains.kotlin.util.SmartPrinter +import org.jetbrains.kotlin.util.withIndent +import java.io.File +import kotlin.reflect.KClass +import kotlin.reflect.full.createType + +private const val CONVERT_ARGUMENT = "convertArgument" + +object ArgumentsConverterGenerator { + fun render(file: File, packageName: String) { + val convertArgumentFunctionCallConversion = HLFunctionCallConversion( + "$CONVERT_ARGUMENT({0}, firSymbolBuilder)", + callType = Any::class.createType(nullable = true) + ) + val convertersMap = FirToKtConversionCreator.getAllConverters(convertArgumentFunctionCallConversion) + file.writeToFileUsingSmartPrinterIfFileContentChanged { generate(packageName, convertersMap) } + } + + private fun SmartPrinter.generate(packageName: String, convertersMap: Map, HLParameterConversion>) { + printCopyright() + println("@file:Suppress(\"UNUSED_PARAMETER\")") + println() + println("package $packageName") + println() + collectAndPrintImports(convertersMap) + println() + printGeneratedMessage() + + generateDispatchingConverter(convertersMap) + for ((type, converter) in convertersMap) { + generateSingleConverter(type, converter) + } + } + + private fun SmartPrinter.collectAndPrintImports(convertersMap: Map, HLParameterConversion>) { + val imports = buildList { + add("org.jetbrains.kotlin.analysis.api.fir.KtSymbolByFirBuilder") + add("org.jetbrains.kotlin.analysis.api.fir.KtFirAnalysisSession") + convertersMap.values.flatMapTo(this) { it.importsToAdd } + convertersMap.keys.mapNotNullTo(this) { it.qualifiedName } + } + printImports(imports) + } + + private fun SmartPrinter.generateDispatchingConverter(convertersMap: Map, HLParameterConversion>) { + println("internal fun $CONVERT_ARGUMENT(argument: Any?, analysisSession: KtFirAnalysisSession): Any? {") + withIndent { + println("return $CONVERT_ARGUMENT(argument, analysisSession.firSymbolBuilder)") + } + println("}") + println() + + println("private fun $CONVERT_ARGUMENT(argument: Any?, firSymbolBuilder: KtSymbolByFirBuilder): Any? {") + withIndent { + println("return when (argument) {") + withIndent { + println("null -> null") + for (type in convertersMap.keys) { + println("is ${type.typeWithStars} -> $CONVERT_ARGUMENT(argument, firSymbolBuilder)") + } + println("else -> argument") + } + println("}") + } + println("}") + println() + } + + private fun SmartPrinter.generateSingleConverter(type: KClass<*>, converter: HLParameterConversion) { + println("private fun $CONVERT_ARGUMENT(argument: ${type.typeWithStars}, firSymbolBuilder: KtSymbolByFirBuilder): Any? {") + withIndent { + println("return ${converter.convertExpression("argument", ConversionContext(getCurrentIndentInUnits(), getIndentUnit()))}") + } + println("}") + println() + } + + private val KClass<*>.typeWithStars: String + get() = buildString { + append(simpleName) + if (typeParameters.isNotEmpty()) { + append(typeParameters.joinToString(", ", "<", ">") { "*" }) + } + } +} diff --git a/analysis/analysis-api-fir/analysis-api-fir-generator/src/org/jetbrains/kotlin/analysis/api/fir/generator/DiagnosticClassGenerator.kt b/analysis/analysis-api-fir/analysis-api-fir-generator/src/org/jetbrains/kotlin/analysis/api/fir/generator/DiagnosticClassGenerator.kt index 3637a6041f9..a6567fddf64 100644 --- a/analysis/analysis-api-fir/analysis-api-fir-generator/src/org/jetbrains/kotlin/analysis/api/fir/generator/DiagnosticClassGenerator.kt +++ b/analysis/analysis-api-fir/analysis-api-fir-generator/src/org/jetbrains/kotlin/analysis/api/fir/generator/DiagnosticClassGenerator.kt @@ -18,5 +18,6 @@ object DiagnosticClassGenerator { KtDiagnosticClassRenderer.render(path.resolve("KtFirDiagnostics.kt"), diagnosticList, packageName, emptySet()) KtDiagnosticClassImplementationRenderer.render(path.resolve("KtFirDiagnosticsImpl.kt"), diagnosticList, packageName, emptySet()) FirDiagnosticToKtDiagnosticConverterRenderer.render(path.resolve("KtFirDataClassConverters.kt"), diagnosticList, packageName, emptySet()) + ArgumentsConverterGenerator.render(path.resolve("KtFirArgumentsConverter.kt"), packageName) } } diff --git a/analysis/analysis-api-fir/analysis-api-fir-generator/src/org/jetbrains/kotlin/analysis/api/fir/generator/HLDiagnosticConverter.kt b/analysis/analysis-api-fir/analysis-api-fir-generator/src/org/jetbrains/kotlin/analysis/api/fir/generator/HLDiagnosticConverter.kt index a6957d7cf18..855e59c4fd2 100644 --- a/analysis/analysis-api-fir/analysis-api-fir-generator/src/org/jetbrains/kotlin/analysis/api/fir/generator/HLDiagnosticConverter.kt +++ b/analysis/analysis-api-fir/analysis-api-fir-generator/src/org/jetbrains/kotlin/analysis/api/fir/generator/HLDiagnosticConverter.kt @@ -43,7 +43,6 @@ import kotlin.reflect.full.createType import kotlin.reflect.full.isSubclassOf object HLDiagnosticConverter { - @OptIn(ExperimentalStdlibApi::class) fun convert(diagnosticList: DiagnosticList): HLDiagnosticList { return HLDiagnosticList(diagnosticList.allDiagnostics.flatMap(::convertDiagnostic)) } @@ -107,8 +106,7 @@ object HLDiagnosticConverter { } - -private object FirToKtConversionCreator { +internal object FirToKtConversionCreator { fun createConversion(type: KType): HLParameterConversion { val nullable = type.isMarkedNullable val kClass = type.classifier as KClass<*> @@ -119,6 +117,32 @@ private object FirToKtConversionCreator { ?: error("Unsupported type $type, consider add corresponding mapping") } + fun getAllConverters(conversionForCollectionValues: HLParameterConversion): Map, HLParameterConversion> { + return buildMap { + putAll(typeMapping) + put( + Map::class, + HLMapParameterConversion( + "key", + "value", + conversionForCollectionValues, + conversionForCollectionValues + ) + ) + put( + Collection::class, + HLCollectionParameterConversion("value", conversionForCollectionValues) + ) + put( + Pair::class, + HLPairParameterConversion( + conversionForCollectionValues, + conversionForCollectionValues + ) + ) + } + } + private fun tryMapFirTypeToKtType(kClass: KClass<*>, nullable: Boolean): HLParameterConversion? { return if (nullable) { nullableTypeMapping[kClass] ?: typeMapping[kClass] @@ -188,19 +212,7 @@ private object FirToKtConversionCreator { ) private val typeMapping: Map, HLFunctionCallConversion> = mapOf( - FirBasedSymbol::class to HLFunctionCallConversion( - "firSymbolBuilder.buildSymbol({0})", - KtSymbol::class.createType(), - importsToAdd = listOf("org.jetbrains.kotlin.fir.declarations.FirDeclaration") - ), - FirClass::class to HLFunctionCallConversion( - "firSymbolBuilder.classifierBuilder.buildClassLikeSymbol({0}.symbol)", - KtClassLikeSymbol::class.createType() - ), - FirClassSymbol::class to HLFunctionCallConversion( - "firSymbolBuilder.classifierBuilder.buildClassLikeSymbol({0})", - KtClassLikeSymbol::class.createType() - ), + // ------------------ symbols ------------------ FirRegularClass::class to HLFunctionCallConversion( "firSymbolBuilder.classifierBuilder.buildClassLikeSymbol({0}.symbol) as KtNamedClassOrObjectSymbol", KtNamedClassOrObjectSymbol::class.createType(), @@ -209,27 +221,6 @@ private object FirToKtConversionCreator { "org.jetbrains.kotlin.analysis.api.symbols.KtNamedClassOrObjectSymbol" ) ), - FirExpression::class to HLFunctionCallConversion( - "{0}.source!!.psi as KtExpression", - KtExpression::class.createType(), - importsToAdd = listOf( - "org.jetbrains.kotlin.psi.KtExpression", - "org.jetbrains.kotlin.psi" - ) - ), - FirQualifiedAccess::class to HLFunctionCallConversion( - "{0}.source!!.psi as KtExpression", - KtExpression::class.createType(), - importsToAdd = listOf( - "org.jetbrains.kotlin.psi.KtExpression", - "org.jetbrains.kotlin.psi" - ) - ), - FirValueParameter::class to HLFunctionCallConversion( - "firSymbolBuilder.buildSymbol({0}.symbol)", - KtSymbol::class.createType(), - importsToAdd = listOf("org.jetbrains.kotlin.fir.declarations.FirDeclaration") - ), FirValueParameterSymbol::class to HLFunctionCallConversion( "firSymbolBuilder.buildSymbol({0})", KtSymbol::class.createType(), @@ -239,66 +230,58 @@ private object FirToKtConversionCreator { "firSymbolBuilder.buildSymbol({0})", KtSymbol::class.createType(), ), - FirClassLikeSymbol::class to HLFunctionCallConversion( - "firSymbolBuilder.classifierBuilder.buildClassLikeSymbol({0})", - KtClassLikeSymbol::class.createType(), - importsToAdd = listOf("org.jetbrains.kotlin.fir.declarations.FirClass") - ), FirRegularClassSymbol::class to HLFunctionCallConversion( "firSymbolBuilder.classifierBuilder.buildClassLikeSymbol({0})", - KtClassLikeSymbol::class.createType(), - importsToAdd = listOf("org.jetbrains.kotlin.fir.declarations.FirRegularClass") + KtClassLikeSymbol::class.createType() ), - FirMemberDeclaration::class to HLFunctionCallConversion( - "firSymbolBuilder.buildSymbol({0} as FirDeclaration)", - KtSymbol::class.createType(), - importsToAdd = listOf("org.jetbrains.kotlin.fir.declarations.FirDeclaration") - ), - FirCallableDeclaration::class to HLFunctionCallConversion( - "firSymbolBuilder.callableBuilder.buildCallableSymbol({0} as FirCallableDeclaration)", - KtCallableSymbol::class.createType(), - importsToAdd = listOf("org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration") - ), - FirCallableSymbol::class to HLFunctionCallConversion( - "firSymbolBuilder.callableBuilder.buildCallableSymbol({0})", - KtCallableSymbol::class.createType(), - importsToAdd = listOf("org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration") - ), - FirTypeParameterSymbol::class to HLFunctionCallConversion( - "firSymbolBuilder.classifierBuilder.buildTypeParameterSymbol({0})", - KtTypeParameterSymbol::class.createType(), - importsToAdd = listOf("org.jetbrains.kotlin.fir.declarations.FirTypeParameter") - ), - FirTypeParameter::class to HLFunctionCallConversion( - "firSymbolBuilder.classifierBuilder.buildTypeParameterSymbol({0})", - KtTypeParameterSymbol::class.createType(), - importsToAdd = listOf("org.jetbrains.kotlin.fir.declarations.FirTypeParameter") - ), - ConeKotlinType::class to HLFunctionCallConversion( - "firSymbolBuilder.typeBuilder.buildKtType({0})", - KtType::class.createType() - ), - FirTypeRef::class to HLFunctionCallConversion( - "firSymbolBuilder.typeBuilder.buildKtType({0})", - KtType::class.createType() + FirNamedFunctionSymbol::class to HLFunctionCallConversion( + "firSymbolBuilder.functionLikeBuilder.buildFunctionSymbol({0})", + KtFunctionLikeSymbol::class.createType() ), FirPropertySymbol::class to HLFunctionCallConversion( "firSymbolBuilder.variableLikeBuilder.buildVariableSymbol({0})", - KtVariableSymbol::class.createType(), - importsToAdd = listOf("org.jetbrains.kotlin.fir.declarations.FirProperty") + KtVariableSymbol::class.createType() ), FirBackingFieldSymbol::class to HLFunctionCallConversion( "firSymbolBuilder.variableLikeBuilder.buildVariableSymbol({0}.fir.propertySymbol)", - KtVariableSymbol::class.createType(), - importsToAdd = listOf("org.jetbrains.kotlin.fir.declarations.FirProperty") + KtVariableSymbol::class.createType() ), FirVariableSymbol::class to HLFunctionCallConversion( "firSymbolBuilder.variableLikeBuilder.buildVariableLikeSymbol({0})", - KtVariableLikeSymbol::class.createType(), - importsToAdd = listOf("org.jetbrains.kotlin.fir.declarations.FirVariable") + KtVariableLikeSymbol::class.createType() ), - FirDeclaration::class to HLFunctionCallConversion( + FirTypeParameterSymbol::class to HLFunctionCallConversion( + "firSymbolBuilder.classifierBuilder.buildTypeParameterSymbol({0})", + KtTypeParameterSymbol::class.createType() + ), + FirCallableSymbol::class to HLFunctionCallConversion( + "firSymbolBuilder.callableBuilder.buildCallableSymbol({0})", + KtCallableSymbol::class.createType() + ), + FirClassSymbol::class to HLFunctionCallConversion( + "firSymbolBuilder.classifierBuilder.buildClassLikeSymbol({0})", + KtClassLikeSymbol::class.createType() + ), + FirClassLikeSymbol::class to HLFunctionCallConversion( + "firSymbolBuilder.classifierBuilder.buildClassLikeSymbol({0})", + KtClassLikeSymbol::class.createType() + ), + FirBasedSymbol::class to HLFunctionCallConversion( "firSymbolBuilder.buildSymbol({0})", + KtSymbol::class.createType() + ), + // ------------------ FIR elements ------------------ + FirClass::class to HLFunctionCallConversion( + "firSymbolBuilder.classifierBuilder.buildClassLikeSymbol({0}.symbol)", + KtClassLikeSymbol::class.createType() + ), + FirTypeParameter::class to HLFunctionCallConversion( + "firSymbolBuilder.classifierBuilder.buildTypeParameterSymbol({0}.symbol)", + KtTypeParameterSymbol::class.createType(), + importsToAdd = listOf("org.jetbrains.kotlin.fir.declarations.FirTypeParameter") + ), + FirValueParameter::class to HLFunctionCallConversion( + "firSymbolBuilder.buildSymbol({0}.symbol)", KtSymbol::class.createType(), importsToAdd = listOf("org.jetbrains.kotlin.fir.declarations.FirDeclaration") ), @@ -307,10 +290,46 @@ private object FirToKtConversionCreator { KtSymbol::class.createType(), importsToAdd = listOf("org.jetbrains.kotlin.fir.declarations.FirFunction") ), - FirNamedFunctionSymbol::class to HLFunctionCallConversion( - "firSymbolBuilder.functionLikeBuilder.buildFunctionSymbol({0})", - KtFunctionLikeSymbol::class.createType(), - importsToAdd = listOf("org.jetbrains.kotlin.fir.declarations.FirSimpleFunction") + FirCallableDeclaration::class to HLFunctionCallConversion( + "firSymbolBuilder.callableBuilder.buildCallableSymbol({0}.symbol)", + KtCallableSymbol::class.createType(), + importsToAdd = listOf("org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration") + ), + FirMemberDeclaration::class to HLFunctionCallConversion( + "firSymbolBuilder.buildSymbol({0} as FirDeclaration)", + KtSymbol::class.createType(), + importsToAdd = listOf("org.jetbrains.kotlin.fir.declarations.FirDeclaration") + ), + FirDeclaration::class to HLFunctionCallConversion( + "firSymbolBuilder.buildSymbol({0})", + KtSymbol::class.createType(), + importsToAdd = listOf("org.jetbrains.kotlin.fir.declarations.FirDeclaration") + ), + FirQualifiedAccess::class to HLFunctionCallConversion( + "{0}.source!!.psi as KtExpression", + KtExpression::class.createType(), + importsToAdd = listOf( + "org.jetbrains.kotlin.psi.KtExpression", + "org.jetbrains.kotlin.psi" + ) + ), + FirExpression::class to HLFunctionCallConversion( + "{0}.source!!.psi as KtExpression", + KtExpression::class.createType(), + importsToAdd = listOf( + "org.jetbrains.kotlin.psi.KtExpression", + "org.jetbrains.kotlin.psi" + ) + ), + // ------------------ other ------------------ + + ConeKotlinType::class to HLFunctionCallConversion( + "firSymbolBuilder.typeBuilder.buildKtType({0})", + KtType::class.createType() + ), + FirTypeRef::class to HLFunctionCallConversion( + "firSymbolBuilder.typeBuilder.buildKtType({0})", + KtType::class.createType() ), KtSourceElement::class to HLFunctionCallConversion( "({0} as KtPsiSourceElement).psi", diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtCompilerPluginDiagnostic.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtCompilerPluginDiagnostic.kt new file mode 100644 index 00000000000..25506374726 --- /dev/null +++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtCompilerPluginDiagnostic.kt @@ -0,0 +1,47 @@ +/* + * Copyright 2010-2022 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.analysis.api.fir.diagnostics + +import com.intellij.psi.PsiElement + +abstract class KtCompilerPluginDiagnostic0 : KtFirDiagnostic(), KtAbstractFirDiagnostic { + final override val diagnosticClass + get() = KtCompilerPluginDiagnostic0::class +} + +abstract class KtCompilerPluginDiagnostic1 : KtFirDiagnostic(), KtAbstractFirDiagnostic { + abstract val parameter1: Any? + + final override val diagnosticClass + get() = KtCompilerPluginDiagnostic1::class +} + +abstract class KtCompilerPluginDiagnostic2 : KtFirDiagnostic(), KtAbstractFirDiagnostic { + abstract val parameter1: Any? + abstract val parameter2: Any? + + final override val diagnosticClass + get() = KtCompilerPluginDiagnostic2::class +} + +abstract class KtCompilerPluginDiagnostic3 : KtFirDiagnostic(), KtAbstractFirDiagnostic { + abstract val parameter1: Any? + abstract val parameter2: Any? + abstract val parameter3: Any? + + final override val diagnosticClass + get() = KtCompilerPluginDiagnostic3::class +} + +abstract class KtCompilerPluginDiagnostic4 : KtFirDiagnostic(), KtAbstractFirDiagnostic { + abstract val parameter1: Any? + abstract val parameter2: Any? + abstract val parameter3: Any? + abstract val parameter4: Any? + + final override val diagnosticClass + get() = KtCompilerPluginDiagnostic4::class +} diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtCompilerPluginDiagnosticImpl.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtCompilerPluginDiagnosticImpl.kt new file mode 100644 index 00000000000..5420d891932 --- /dev/null +++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtCompilerPluginDiagnosticImpl.kt @@ -0,0 +1,44 @@ +/* + * Copyright 2010-2022 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.analysis.api.fir.diagnostics + +import org.jetbrains.kotlin.analysis.api.lifetime.KtLifetimeToken +import org.jetbrains.kotlin.diagnostics.* + +internal class KtCompilerPluginDiagnostic0Impl( + override val firDiagnostic: KtPsiSimpleDiagnostic, + override val token: KtLifetimeToken +) : KtCompilerPluginDiagnostic0() + +internal class KtCompilerPluginDiagnostic1Impl( + override val firDiagnostic: KtPsiDiagnosticWithParameters1<*>, + override val token: KtLifetimeToken, + override val parameter1: Any? +) : KtCompilerPluginDiagnostic1() + +internal class KtCompilerPluginDiagnostic2Impl( + override val firDiagnostic: KtPsiDiagnosticWithParameters2<*, *>, + override val token: KtLifetimeToken, + override val parameter1: Any?, + override val parameter2: Any? +) : KtCompilerPluginDiagnostic2() + +internal class KtCompilerPluginDiagnostic3Impl( + override val firDiagnostic: KtPsiDiagnosticWithParameters3<*, *, *>, + override val token: KtLifetimeToken, + override val parameter1: Any?, + override val parameter2: Any?, + override val parameter3: Any? +) : KtCompilerPluginDiagnostic3() + +internal class KtCompilerPluginDiagnostic4Impl( + override val firDiagnostic: KtPsiDiagnosticWithParameters4<*, *, *, *>, + override val token: KtLifetimeToken, + override val parameter1: Any?, + override val parameter2: Any?, + override val parameter3: Any?, + override val parameter4: Any? +) : KtCompilerPluginDiagnostic4() diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtDiagnosticConverter.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtDiagnosticConverter.kt index 21e0b3696fc..b77bf3d2a46 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtDiagnosticConverter.kt +++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtDiagnosticConverter.kt @@ -32,8 +32,7 @@ internal fun interface KtFirDiagnostic4Creator : KtFirDiagnosticCrea internal class KtDiagnosticConverter(private val conversions: Map) { fun convert(analysisSession: KtFirAnalysisSession, diagnostic: KtDiagnostic): KtFirDiagnostic<*> { - val creator = conversions[diagnostic.factory] - ?: error("No conversion was found for ${diagnostic.factory}") + val creator = conversions[diagnostic.factory] ?: buildCreatorForPluginDiagnostic(diagnostic.factory) @Suppress("UNCHECKED_CAST") return with(analysisSession) { @@ -57,6 +56,49 @@ internal class KtDiagnosticConverter(private val conversions: Map KtFirDiagnostic0Creator { + KtCompilerPluginDiagnostic0Impl(it as KtPsiSimpleDiagnostic, token) + } + is KtDiagnosticFactory1<*> -> KtFirDiagnostic1Creator { + KtCompilerPluginDiagnostic1Impl( + it as KtPsiDiagnosticWithParameters1<*>, + token, + convertArgument(it.a, this) + ) + } + is KtDiagnosticFactory2<*, *> -> KtFirDiagnostic2Creator { + KtCompilerPluginDiagnostic2Impl( + it as KtPsiDiagnosticWithParameters2<*, *>, + token, + convertArgument(it.a, this), + convertArgument(it.b, this) + ) + } + is KtDiagnosticFactory3<*, *, *> -> KtFirDiagnostic3Creator { + KtCompilerPluginDiagnostic3Impl( + it as KtPsiDiagnosticWithParameters3<*, *, *>, + token, + convertArgument(it.a, this), + convertArgument(it.b, this), + convertArgument(it.c, this) + ) + } + is KtDiagnosticFactory4<*, *, *, *> -> KtFirDiagnostic4Creator { + KtCompilerPluginDiagnostic4Impl( + it as KtPsiDiagnosticWithParameters4<*, *, *, *>, + token, + convertArgument(it.a, this), + convertArgument(it.b, this), + convertArgument(it.c, this), + convertArgument(it.d, this) + ) + } + } + } } internal class KtDiagnosticConverterBuilder private constructor() { diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirArgumentsConverter.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirArgumentsConverter.kt new file mode 100644 index 00000000000..4f8eb68fd23 --- /dev/null +++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirArgumentsConverter.kt @@ -0,0 +1,203 @@ +/* + * Copyright 2010-2021 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. + */ + +@file:Suppress("UNUSED_PARAMETER") + +package org.jetbrains.kotlin.analysis.api.fir.diagnostics + +import org.jetbrains.kotlin.KtPsiSourceElement +import org.jetbrains.kotlin.KtSourceElement +import org.jetbrains.kotlin.analysis.api.fir.KtFirAnalysisSession +import org.jetbrains.kotlin.analysis.api.fir.KtSymbolByFirBuilder +import org.jetbrains.kotlin.analysis.api.symbols.KtNamedClassOrObjectSymbol +import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration +import org.jetbrains.kotlin.fir.declarations.FirClass +import org.jetbrains.kotlin.fir.declarations.FirDeclaration +import org.jetbrains.kotlin.fir.declarations.FirFunction +import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration +import org.jetbrains.kotlin.fir.declarations.FirRegularClass +import org.jetbrains.kotlin.fir.declarations.FirTypeParameter +import org.jetbrains.kotlin.fir.declarations.FirValueParameter +import org.jetbrains.kotlin.fir.expressions.FirExpression +import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccess +import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirBackingFieldSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirEnumEntrySymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirValueParameterSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol +import org.jetbrains.kotlin.fir.types.ConeKotlinType +import org.jetbrains.kotlin.fir.types.FirTypeRef +import org.jetbrains.kotlin.psi +import org.jetbrains.kotlin.psi.KtExpression + +/* + * This file was generated automatically + * DO NOT MODIFY IT MANUALLY + */ + +internal fun convertArgument(argument: Any?, analysisSession: KtFirAnalysisSession): Any? { + return convertArgument(argument, analysisSession.firSymbolBuilder) +} + +private fun convertArgument(argument: Any?, firSymbolBuilder: KtSymbolByFirBuilder): Any? { + return when (argument) { + null -> null + is FirRegularClass -> convertArgument(argument, firSymbolBuilder) + is FirValueParameterSymbol -> convertArgument(argument, firSymbolBuilder) + is FirEnumEntrySymbol -> convertArgument(argument, firSymbolBuilder) + is FirRegularClassSymbol -> convertArgument(argument, firSymbolBuilder) + is FirNamedFunctionSymbol -> convertArgument(argument, firSymbolBuilder) + is FirPropertySymbol -> convertArgument(argument, firSymbolBuilder) + is FirBackingFieldSymbol -> convertArgument(argument, firSymbolBuilder) + is FirVariableSymbol<*> -> convertArgument(argument, firSymbolBuilder) + is FirTypeParameterSymbol -> convertArgument(argument, firSymbolBuilder) + is FirCallableSymbol<*> -> convertArgument(argument, firSymbolBuilder) + is FirClassSymbol<*> -> convertArgument(argument, firSymbolBuilder) + is FirClassLikeSymbol<*> -> convertArgument(argument, firSymbolBuilder) + is FirBasedSymbol<*> -> convertArgument(argument, firSymbolBuilder) + is FirClass -> convertArgument(argument, firSymbolBuilder) + is FirTypeParameter -> convertArgument(argument, firSymbolBuilder) + is FirValueParameter -> convertArgument(argument, firSymbolBuilder) + is FirFunction -> convertArgument(argument, firSymbolBuilder) + is FirCallableDeclaration -> convertArgument(argument, firSymbolBuilder) + is FirMemberDeclaration -> convertArgument(argument, firSymbolBuilder) + is FirDeclaration -> convertArgument(argument, firSymbolBuilder) + is FirQualifiedAccess -> convertArgument(argument, firSymbolBuilder) + is FirExpression -> convertArgument(argument, firSymbolBuilder) + is ConeKotlinType -> convertArgument(argument, firSymbolBuilder) + is FirTypeRef -> convertArgument(argument, firSymbolBuilder) + is KtSourceElement -> convertArgument(argument, firSymbolBuilder) + is Map<*, *> -> convertArgument(argument, firSymbolBuilder) + is Collection<*> -> convertArgument(argument, firSymbolBuilder) + is Pair<*, *> -> convertArgument(argument, firSymbolBuilder) + else -> argument + } +} + +private fun convertArgument(argument: FirRegularClass, firSymbolBuilder: KtSymbolByFirBuilder): Any? { + return firSymbolBuilder.classifierBuilder.buildClassLikeSymbol(argument.symbol) as KtNamedClassOrObjectSymbol +} + +private fun convertArgument(argument: FirValueParameterSymbol, firSymbolBuilder: KtSymbolByFirBuilder): Any? { + return firSymbolBuilder.buildSymbol(argument) +} + +private fun convertArgument(argument: FirEnumEntrySymbol, firSymbolBuilder: KtSymbolByFirBuilder): Any? { + return firSymbolBuilder.buildSymbol(argument) +} + +private fun convertArgument(argument: FirRegularClassSymbol, firSymbolBuilder: KtSymbolByFirBuilder): Any? { + return firSymbolBuilder.classifierBuilder.buildClassLikeSymbol(argument) +} + +private fun convertArgument(argument: FirNamedFunctionSymbol, firSymbolBuilder: KtSymbolByFirBuilder): Any? { + return firSymbolBuilder.functionLikeBuilder.buildFunctionSymbol(argument) +} + +private fun convertArgument(argument: FirPropertySymbol, firSymbolBuilder: KtSymbolByFirBuilder): Any? { + return firSymbolBuilder.variableLikeBuilder.buildVariableSymbol(argument) +} + +private fun convertArgument(argument: FirBackingFieldSymbol, firSymbolBuilder: KtSymbolByFirBuilder): Any? { + return firSymbolBuilder.variableLikeBuilder.buildVariableSymbol(argument.fir.propertySymbol) +} + +private fun convertArgument(argument: FirVariableSymbol<*>, firSymbolBuilder: KtSymbolByFirBuilder): Any? { + return firSymbolBuilder.variableLikeBuilder.buildVariableLikeSymbol(argument) +} + +private fun convertArgument(argument: FirTypeParameterSymbol, firSymbolBuilder: KtSymbolByFirBuilder): Any? { + return firSymbolBuilder.classifierBuilder.buildTypeParameterSymbol(argument) +} + +private fun convertArgument(argument: FirCallableSymbol<*>, firSymbolBuilder: KtSymbolByFirBuilder): Any? { + return firSymbolBuilder.callableBuilder.buildCallableSymbol(argument) +} + +private fun convertArgument(argument: FirClassSymbol<*>, firSymbolBuilder: KtSymbolByFirBuilder): Any? { + return firSymbolBuilder.classifierBuilder.buildClassLikeSymbol(argument) +} + +private fun convertArgument(argument: FirClassLikeSymbol<*>, firSymbolBuilder: KtSymbolByFirBuilder): Any? { + return firSymbolBuilder.classifierBuilder.buildClassLikeSymbol(argument) +} + +private fun convertArgument(argument: FirBasedSymbol<*>, firSymbolBuilder: KtSymbolByFirBuilder): Any? { + return firSymbolBuilder.buildSymbol(argument) +} + +private fun convertArgument(argument: FirClass, firSymbolBuilder: KtSymbolByFirBuilder): Any? { + return firSymbolBuilder.classifierBuilder.buildClassLikeSymbol(argument.symbol) +} + +private fun convertArgument(argument: FirTypeParameter, firSymbolBuilder: KtSymbolByFirBuilder): Any? { + return firSymbolBuilder.classifierBuilder.buildTypeParameterSymbol(argument.symbol) +} + +private fun convertArgument(argument: FirValueParameter, firSymbolBuilder: KtSymbolByFirBuilder): Any? { + return firSymbolBuilder.buildSymbol(argument.symbol) +} + +private fun convertArgument(argument: FirFunction, firSymbolBuilder: KtSymbolByFirBuilder): Any? { + return firSymbolBuilder.buildSymbol(argument) +} + +private fun convertArgument(argument: FirCallableDeclaration, firSymbolBuilder: KtSymbolByFirBuilder): Any? { + return firSymbolBuilder.callableBuilder.buildCallableSymbol(argument.symbol) +} + +private fun convertArgument(argument: FirMemberDeclaration, firSymbolBuilder: KtSymbolByFirBuilder): Any? { + return firSymbolBuilder.buildSymbol(argument as FirDeclaration) +} + +private fun convertArgument(argument: FirDeclaration, firSymbolBuilder: KtSymbolByFirBuilder): Any? { + return firSymbolBuilder.buildSymbol(argument) +} + +private fun convertArgument(argument: FirQualifiedAccess, firSymbolBuilder: KtSymbolByFirBuilder): Any? { + return argument.source!!.psi as KtExpression +} + +private fun convertArgument(argument: FirExpression, firSymbolBuilder: KtSymbolByFirBuilder): Any? { + return argument.source!!.psi as KtExpression +} + +private fun convertArgument(argument: ConeKotlinType, firSymbolBuilder: KtSymbolByFirBuilder): Any? { + return firSymbolBuilder.typeBuilder.buildKtType(argument) +} + +private fun convertArgument(argument: FirTypeRef, firSymbolBuilder: KtSymbolByFirBuilder): Any? { + return firSymbolBuilder.typeBuilder.buildKtType(argument) +} + +private fun convertArgument(argument: KtSourceElement, firSymbolBuilder: KtSymbolByFirBuilder): Any? { + return (argument as KtPsiSourceElement).psi +} + +private fun convertArgument(argument: Map<*, *>, firSymbolBuilder: KtSymbolByFirBuilder): Any? { + return argument.mapKeys { (key, _) -> + convertArgument(key, firSymbolBuilder) + }.mapValues { (_, value) -> + convertArgument(value, firSymbolBuilder) + } +} + +private fun convertArgument(argument: Collection<*>, firSymbolBuilder: KtSymbolByFirBuilder): Any? { + return argument.map { value -> + convertArgument(value, firSymbolBuilder) + } +} + +private fun convertArgument(argument: Pair<*, *>, firSymbolBuilder: KtSymbolByFirBuilder): Any? { + return convertArgument(argument.first, firSymbolBuilder) to convertArgument(argument.second, firSymbolBuilder) +} + diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDataClassConverters.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDataClassConverters.kt index 43a879a8d23..f8d06fc4615 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDataClassConverters.kt +++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDataClassConverters.kt @@ -12,15 +12,8 @@ import org.jetbrains.kotlin.diagnostics.KtPsiDiagnostic import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors import org.jetbrains.kotlin.fir.analysis.diagnostics.jvm.FirJvmErrors import org.jetbrains.kotlin.fir.builder.FirSyntaxErrors -import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration -import org.jetbrains.kotlin.fir.declarations.FirClass import org.jetbrains.kotlin.fir.declarations.FirDeclaration import org.jetbrains.kotlin.fir.declarations.FirFunction -import org.jetbrains.kotlin.fir.declarations.FirProperty -import org.jetbrains.kotlin.fir.declarations.FirRegularClass -import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction -import org.jetbrains.kotlin.fir.declarations.FirTypeParameter -import org.jetbrains.kotlin.fir.declarations.FirVariable import org.jetbrains.kotlin.psi import org.jetbrains.kotlin.psi.KtAnnotationEntry import org.jetbrains.kotlin.psi.KtAnonymousInitializer