From 2eba7da5eb205a35cf684bb34ee30f2875d73e52 Mon Sep 17 00:00:00 2001 From: Ivan Kochurkin Date: Fri, 21 Jul 2023 20:10:15 +0200 Subject: [PATCH] [FIR] Rename FirArrayOfCall to FirArrayLiteral --- .../api/fir/components/KtFirCallResolver.kt | 20 +++++++------- .../evaluate/FirAnnotationValueConverter.kt | 2 +- .../references/FirReferenceResolveHelper.kt | 2 +- .../KtFirCollectionLiteralReference.kt | 4 +-- .../StubBasedAnnotationDeserializer.kt | 2 +- .../kotlin/fir/checkers/generator/Main.kt | 2 +- .../expression/ComposedExpressionCheckers.kt | 8 +++--- .../checkers/expression/ExpressionCheckers.kt | 4 +-- .../expression/FirExpressionCheckerAliases.kt | 4 +-- .../checkers/CommonExpressionCheckers.kt | 2 +- .../FirAnnotationExpressionChecker.kt | 2 +- .../expression/FirNamedVarargChecker.kt | 12 ++++----- .../FirUnsupportedArrayLiteralChecker.kt | 10 +++---- .../ExpressionCheckersDiagnosticComponent.kt | 4 +-- .../AbstractAnnotationDeserializer.kt | 2 +- .../constant/FirToConstantValueTransformer.kt | 16 +++++------ .../fir/backend/Fir2IrImplicitCastInserter.kt | 2 +- .../kotlin/fir/backend/Fir2IrVisitor.kt | 14 +++++----- .../jetbrains/kotlin/fir/java/JavaUtils.kt | 27 +++++++++---------- .../java/deserialization/AnnotationsLoader.kt | 2 +- .../FirAnnotationTypeQualifierResolver.kt | 2 +- .../kotlin/fir/java/javaAnnotationsMapping.kt | 8 ++---- .../fir/declarations/FirAnnotationUtils.kt | 4 +-- .../kotlin/fir/types/ConeTypeContext.kt | 2 +- .../LightTreeRawFirExpressionBuilder.kt | 2 +- .../kotlin/fir/builder/PsiRawFirBuilder.kt | 2 +- .../jetbrains/kotlin/fir/FirCallResolver.kt | 2 +- ...rCallCompletionResultsWriterTransformer.kt | 14 +++++----- .../transformers/FirSyntheticCallGenerator.kt | 14 +++++----- ...bstractBodyResolveTransformerDispatcher.kt | 10 +++---- .../body/resolve/FirArrayOfCallTransformer.kt | 14 +++++----- .../FirExpressionsResolveTransformer.kt | 18 ++++++------- ...irAnnotationArgumentsResolveTransformer.kt | 16 +++++------ .../{FirArrayOfCall.kt => FirArrayLiteral.kt} | 8 +++--- ...llBuilder.kt => FirArrayLiteralBuilder.kt} | 14 +++++----- ...ayOfCallImpl.kt => FirArrayLiteralImpl.kt} | 10 +++---- .../kotlin/fir/visitors/FirDefaultVisitor.kt | 2 +- .../fir/visitors/FirDefaultVisitorVoid.kt | 2 +- .../kotlin/fir/visitors/FirTransformer.kt | 10 +++---- .../kotlin/fir/visitors/FirVisitor.kt | 4 +-- .../kotlin/fir/visitors/FirVisitorVoid.kt | 10 +++---- .../fir/expressions/FirExpressionUtil.kt | 2 +- .../kotlin/fir/renderer/FirRenderer.kt | 8 +++--- .../fir/tree/generator/BuilderConfigurator.kt | 4 +-- .../fir/tree/generator/FirTreeBuilder.kt | 2 +- .../generator/ImplementationConfigurator.kt | 4 +-- .../compiler/visualizer/FirVisualizer.kt | 8 +++--- .../FirSerializationPluginClassChecker.kt | 4 +-- .../services/ContextualSerializersProvider.kt | 2 +- 49 files changed, 165 insertions(+), 178 deletions(-) rename compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/{FirArrayOfCall.kt => FirArrayLiteral.kt} (85%) rename compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/builder/{FirArrayOfCallBuilder.kt => FirArrayLiteralBuilder.kt} (77%) rename compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/impl/{FirArrayOfCallImpl.kt => FirArrayLiteralImpl.kt} (90%) diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirCallResolver.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirCallResolver.kt index 5c21b5ea823..d969fdcaef4 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirCallResolver.kt +++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirCallResolver.kt @@ -29,8 +29,6 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getOrBuildFir import org.jetbrains.kotlin.analysis.low.level.api.fir.api.resolveToFirSymbolOfTypeSafe import org.jetbrains.kotlin.analysis.low.level.api.fir.resolver.AllCandidatesResolver import org.jetbrains.kotlin.analysis.low.level.api.fir.util.errorWithFirSpecificEntries -import org.jetbrains.kotlin.fir.utils.exceptions.withFirEntry -import org.jetbrains.kotlin.utils.exceptions.rethrowExceptionWithDetails import org.jetbrains.kotlin.analysis.utils.errors.withPsiEntry import org.jetbrains.kotlin.analysis.utils.printer.parentOfType import org.jetbrains.kotlin.fir.FirElement @@ -59,6 +57,7 @@ import org.jetbrains.kotlin.fir.scopes.unsubstitutedScope import org.jetbrains.kotlin.fir.symbols.SymbolInternals import org.jetbrains.kotlin.fir.symbols.impl.* import org.jetbrains.kotlin.fir.types.* +import org.jetbrains.kotlin.fir.utils.exceptions.withFirEntry import org.jetbrains.kotlin.lexer.KtTokens import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.psi.* @@ -72,6 +71,7 @@ import org.jetbrains.kotlin.util.OperatorNameConventions.EQUALS import org.jetbrains.kotlin.utils.addIfNotNull import org.jetbrains.kotlin.utils.addToStdlib.safeAs import org.jetbrains.kotlin.utils.exceptions.errorWithAttachment +import org.jetbrains.kotlin.utils.exceptions.rethrowExceptionWithDetails internal class KtFirCallResolver( override val analysisSession: KtFirAnalysisSession, @@ -245,7 +245,7 @@ internal class KtFirCallResolver( else -> null } } - is FirArrayOfCall -> toKtCallInfo() + is FirArrayLiteral -> toKtCallInfo() is FirComparisonExpression -> compareToCall.toKtCallInfo( psi, resolveCalleeExpressionOfFunctionCall, @@ -872,7 +872,7 @@ internal class KtFirCallResolver( return result } - private fun FirArrayOfCall.toTypeArgumentsMapping( + private fun FirArrayLiteral.toTypeArgumentsMapping( partiallyAppliedSymbol: KtPartiallyAppliedSymbol<*, *> ): Map { val elementType = typeRef.coneTypeSafe()?.arrayElementType()?.asKtType() ?: return emptyMap() @@ -929,7 +929,7 @@ internal class KtFirCallResolver( resolveCalleeExpressionOfFunctionCall, resolveFragmentOfCall ) - is FirArrayOfCall, is FirEqualityOperatorCall -> { + is FirArrayLiteral, is FirEqualityOperatorCall -> { toKtCallInfo(psi, resolveCalleeExpressionOfFunctionCall, resolveFragmentOfCall).toKtCallCandidateInfos() } is FirComparisonExpression -> compareToCall.toKtCallInfo( @@ -1107,7 +1107,7 @@ internal class KtFirCallResolver( } } - private fun FirArrayOfCall.toKtCallInfo(): KtCallInfo? { + private fun FirArrayLiteral.toKtCallInfo(): KtCallInfo? { val arrayOfSymbol = with(analysisSession) { val type = typeRef.coneTypeSafe() ?: return run { @@ -1150,7 +1150,7 @@ internal class KtFirCallResolver( ) } - private fun FirArrayOfCall.createSubstitutorFromTypeArguments(arrayOfSymbol: KtFirFunctionSymbol): KtSubstitutor { + private fun FirArrayLiteral.createSubstitutorFromTypeArguments(arrayOfSymbol: KtFirFunctionSymbol): KtSubstitutor { val firSymbol = arrayOfSymbol.firSymbol // No type parameter means this is an arrayOf call of primitives, in which case there is no type arguments val typeParameter = firSymbol.fir.typeParameters.singleOrNull() ?: return KtSubstitutor.Empty(token) @@ -1239,12 +1239,12 @@ internal class KtFirCallResolver( return ktArgumentMapping } - private fun FirArrayOfCall.createArgumentMapping( - arrayOfCallSymbol: KtFirFunctionSymbol, + private fun FirArrayLiteral.createArgumentMapping( + arrayOfSymbol: KtFirFunctionSymbol, substitutor: KtSubstitutor, ): LinkedHashMap> { val ktArgumentMapping = LinkedHashMap>() - val parameterSymbol = arrayOfCallSymbol.valueParameters.single() + val parameterSymbol = arrayOfSymbol.valueParameters.single() for (firExpression in argumentList.arguments) { mapArgumentExpressionToParameter( diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/evaluate/FirAnnotationValueConverter.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/evaluate/FirAnnotationValueConverter.kt index 3a2d9126112..26582824ced 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/evaluate/FirAnnotationValueConverter.kt +++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/evaluate/FirAnnotationValueConverter.kt @@ -115,7 +115,7 @@ internal object FirAnnotationValueConverter { KtArrayAnnotationValue(annotationValues, representativePsi ?: sourcePsi) } - is FirArrayOfCall -> { + is FirArrayLiteral -> { // Desugared collection literals. KtArrayAnnotationValue(argumentList.arguments.convertVarargsExpression(session).first, sourcePsi) } diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/references/FirReferenceResolveHelper.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/references/FirReferenceResolveHelper.kt index 30e4c2c4bcc..f98912e34b5 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/references/FirReferenceResolveHelper.kt +++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/references/FirReferenceResolveHelper.kt @@ -227,7 +227,7 @@ internal object FirReferenceResolveHelper { is FirResolvedImport -> getSymbolsByResolvedImport(expression, symbolBuilder, fir, session) is FirPackageDirective -> getSymbolsForPackageDirective(expression, symbolBuilder) is FirFile -> getSymbolsByFirFile(symbolBuilder, fir) - is FirArrayOfCall -> { + is FirArrayLiteral -> { // We can't yet find PsiElement for arrayOf, intArrayOf, etc. emptyList() } diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/references/KtFirCollectionLiteralReference.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/references/KtFirCollectionLiteralReference.kt index 8476d380513..1d7a83510b3 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/references/KtFirCollectionLiteralReference.kt +++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/references/KtFirCollectionLiteralReference.kt @@ -12,7 +12,7 @@ import org.jetbrains.kotlin.analysis.api.fir.symbols.KtFirArrayOfSymbolProvider. import org.jetbrains.kotlin.analysis.api.fir.symbols.KtFirArrayOfSymbolProvider.arrayTypeToArrayOfCall import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getOrBuildFirSafe -import org.jetbrains.kotlin.fir.expressions.FirArrayOfCall +import org.jetbrains.kotlin.fir.expressions.FirArrayLiteral import org.jetbrains.kotlin.fir.types.ConeClassLikeType import org.jetbrains.kotlin.fir.types.coneTypeSafe @@ -23,7 +23,7 @@ class KtFirCollectionLiteralReference( ) : KtCollectionLiteralReference(expression), KtFirReference { override fun KtAnalysisSession.resolveToSymbols(): Collection { check(this is KtFirAnalysisSession) - val fir = element.getOrBuildFirSafe(firResolveSession) ?: return emptyList() + val fir = element.getOrBuildFirSafe(firResolveSession) ?: return emptyList() val type = fir.typeRef.coneTypeSafe() ?: return listOfNotNull(arrayOfSymbol(arrayOf)) val call = arrayTypeToArrayOfCall[type.lookupTag.classId] ?: arrayOf return listOfNotNull(arrayOfSymbol(call)) diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/stubBased/deserialization/StubBasedAnnotationDeserializer.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/stubBased/deserialization/StubBasedAnnotationDeserializer.kt index 0a388c52eac..e357ee7dfac 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/stubBased/deserialization/StubBasedAnnotationDeserializer.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/stubBased/deserialization/StubBasedAnnotationDeserializer.kt @@ -120,7 +120,7 @@ class StubBasedAnnotationDeserializer( ) } is ArrayValue -> { - buildArrayOfCall { + buildArrayLiteral { source = KtRealPsiSourceElement(sourceElement) typeRef = buildResolvedTypeRef { // Not quite precise, yet doesn't require annotation resolution diff --git a/compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/Main.kt b/compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/Main.kt index f925e92c37a..8e091f50479 100644 --- a/compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/Main.kt +++ b/compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/Main.kt @@ -60,7 +60,7 @@ fun main(args: Array) { alias("WhileLoopChecker") alias("ThrowExpressionChecker") alias("DoWhileLoopChecker") - alias("ArrayOfCallChecker") + alias("ArrayLiteralChecker") alias("ClassReferenceExpressionChecker") alias("InaccessibleReceiverChecker") } diff --git a/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/checkers/expression/ComposedExpressionCheckers.kt b/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/checkers/expression/ComposedExpressionCheckers.kt index 0c1417142c1..2b04e4f020a 100644 --- a/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/checkers/expression/ComposedExpressionCheckers.kt +++ b/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/checkers/expression/ComposedExpressionCheckers.kt @@ -73,8 +73,8 @@ class ComposedExpressionCheckers : ExpressionCheckers() { get() = _throwExpressionCheckers override val doWhileLoopCheckers: Set get() = _doWhileLoopCheckers - override val arrayOfCallCheckers: Set - get() = _arrayOfCallCheckers + override val arrayLiteralCheckers: Set + get() = _arrayLiteralCheckers override val classReferenceExpressionCheckers: Set get() = _classReferenceExpressionCheckers override val inaccessibleReceiverCheckers: Set @@ -110,7 +110,7 @@ class ComposedExpressionCheckers : ExpressionCheckers() { private val _whileLoopCheckers: MutableSet = mutableSetOf() private val _throwExpressionCheckers: MutableSet = mutableSetOf() private val _doWhileLoopCheckers: MutableSet = mutableSetOf() - private val _arrayOfCallCheckers: MutableSet = mutableSetOf() + private val _arrayLiteralCheckers: MutableSet = mutableSetOf() private val _classReferenceExpressionCheckers: MutableSet = mutableSetOf() private val _inaccessibleReceiverCheckers: MutableSet = mutableSetOf() @@ -146,7 +146,7 @@ class ComposedExpressionCheckers : ExpressionCheckers() { _whileLoopCheckers += checkers.whileLoopCheckers _throwExpressionCheckers += checkers.throwExpressionCheckers _doWhileLoopCheckers += checkers.doWhileLoopCheckers - _arrayOfCallCheckers += checkers.arrayOfCallCheckers + _arrayLiteralCheckers += checkers.arrayLiteralCheckers _classReferenceExpressionCheckers += checkers.classReferenceExpressionCheckers _inaccessibleReceiverCheckers += checkers.inaccessibleReceiverCheckers } diff --git a/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/checkers/expression/ExpressionCheckers.kt b/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/checkers/expression/ExpressionCheckers.kt index 78419a0ece1..22bf5c6fdbc 100644 --- a/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/checkers/expression/ExpressionCheckers.kt +++ b/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/checkers/expression/ExpressionCheckers.kt @@ -47,7 +47,7 @@ abstract class ExpressionCheckers { open val whileLoopCheckers: Set = emptySet() open val throwExpressionCheckers: Set = emptySet() open val doWhileLoopCheckers: Set = emptySet() - open val arrayOfCallCheckers: Set = emptySet() + open val arrayLiteralCheckers: Set = emptySet() open val classReferenceExpressionCheckers: Set = emptySet() open val inaccessibleReceiverCheckers: Set = emptySet() @@ -81,7 +81,7 @@ abstract class ExpressionCheckers { @CheckersComponentInternal internal val allWhileLoopCheckers: Set by lazy { whileLoopCheckers + loopExpressionCheckers + basicExpressionCheckers } @CheckersComponentInternal internal val allThrowExpressionCheckers: Set by lazy { throwExpressionCheckers + basicExpressionCheckers } @CheckersComponentInternal internal val allDoWhileLoopCheckers: Set by lazy { doWhileLoopCheckers + loopExpressionCheckers + basicExpressionCheckers } - @CheckersComponentInternal internal val allArrayOfCallCheckers: Set by lazy { arrayOfCallCheckers + basicExpressionCheckers + callCheckers } + @CheckersComponentInternal internal val allArrayLiteralCheckers: Set by lazy { arrayLiteralCheckers + basicExpressionCheckers + callCheckers } @CheckersComponentInternal internal val allClassReferenceExpressionCheckers: Set by lazy { classReferenceExpressionCheckers + basicExpressionCheckers } @CheckersComponentInternal internal val allInaccessibleReceiverCheckers: Set by lazy { inaccessibleReceiverCheckers + basicExpressionCheckers } } diff --git a/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirExpressionCheckerAliases.kt b/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirExpressionCheckerAliases.kt index 0c3cd57c1b6..d5236c65c45 100644 --- a/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirExpressionCheckerAliases.kt +++ b/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirExpressionCheckerAliases.kt @@ -12,7 +12,7 @@ package org.jetbrains.kotlin.fir.analysis.checkers.expression import org.jetbrains.kotlin.fir.expressions.FirAnnotation import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall -import org.jetbrains.kotlin.fir.expressions.FirArrayOfCall +import org.jetbrains.kotlin.fir.expressions.FirArrayLiteral import org.jetbrains.kotlin.fir.expressions.FirBinaryLogicExpression import org.jetbrains.kotlin.fir.expressions.FirBlock import org.jetbrains.kotlin.fir.expressions.FirCall @@ -74,6 +74,6 @@ typealias FirThisReceiverExpressionChecker = FirExpressionChecker typealias FirThrowExpressionChecker = FirExpressionChecker typealias FirDoWhileLoopChecker = FirExpressionChecker -typealias FirArrayOfCallChecker = FirExpressionChecker +typealias FirArrayLiteralChecker = FirExpressionChecker typealias FirClassReferenceExpressionChecker = FirExpressionChecker typealias FirInaccessibleReceiverChecker = FirExpressionChecker diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/CommonExpressionCheckers.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/CommonExpressionCheckers.kt index 66101ddb804..d30b87c7023 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/CommonExpressionCheckers.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/CommonExpressionCheckers.kt @@ -165,7 +165,7 @@ object CommonExpressionCheckers : ExpressionCheckers() { FirEqualityCompatibilityChecker, ) - override val arrayOfCallCheckers: Set + override val arrayLiteralCheckers: Set get() = setOf( FirUnsupportedArrayLiteralChecker ) diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirAnnotationExpressionChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirAnnotationExpressionChecker.kt index fce5a254963..d6ea83fd980 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirAnnotationExpressionChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirAnnotationExpressionChecker.kt @@ -81,7 +81,7 @@ object FirAnnotationExpressionChecker : FirAnnotationCallChecker() { } when (expression) { - is FirArrayOfCall -> return checkArgumentList(expression.argumentList) + is FirArrayLiteral -> return checkArgumentList(expression.argumentList) is FirVarargArgumentsExpression -> { for (arg in expression.arguments) { val unwrappedArg = arg.unwrapArgument() diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirNamedVarargChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirNamedVarargChecker.kt index d25cfa3a10e..2601eaa5831 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirNamedVarargChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirNamedVarargChecker.kt @@ -11,10 +11,10 @@ package org.jetbrains.kotlin.fir.analysis.checkers.expression import org.jetbrains.kotlin.config.LanguageFeature -import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext import org.jetbrains.kotlin.diagnostics.DiagnosticReporter -import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors import org.jetbrains.kotlin.diagnostics.reportOn +import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext +import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors import org.jetbrains.kotlin.fir.expressions.* import org.jetbrains.kotlin.fir.languageVersionSettings import org.jetbrains.kotlin.fir.references.FirErrorNamedReference @@ -25,7 +25,7 @@ object FirNamedVarargChecker : FirCallChecker() { if (expression !is FirFunctionCall && expression !is FirAnnotation && expression !is FirDelegatedConstructorCall && - expression !is FirArrayOfCall) return + expression !is FirArrayLiteral) return val isAnnotation = expression is FirAnnotation val redundantSpreadWarningFactory = if (isAnnotation) FirErrors.REDUNDANT_SPREAD_OPERATOR_IN_NAMED_FORM_IN_ANNOTATION @@ -46,7 +46,7 @@ object FirNamedVarargChecker : FirCallChecker() { } val typeRef = argument.expression.typeRef if (typeRef is FirErrorTypeRef) return - if (argument.expression is FirArrayOfCall) return + if (argument.expression is FirArrayLiteral) return @OptIn(UnexpandedTypeCheck::class) if (allowAssignArray && typeRef.isArrayType) return @@ -68,8 +68,8 @@ object FirNamedVarargChecker : FirCallChecker() { } } - if (expression is FirArrayOfCall) { - // FirArrayOfCall has the `vararg` argument expression pre-flattened and doesn't have an argument mapping. + if (expression is FirArrayLiteral) { + // FirArrayLiteral has the `vararg` argument expression pre-flattened and doesn't have an argument mapping. expression.arguments.forEach { checkArgument(it, it is FirNamedArgumentExpression, expression.typeRef.coneTypeOrNull) } } else { val argumentMap = expression.resolvedArgumentMapping ?: return diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirUnsupportedArrayLiteralChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirUnsupportedArrayLiteralChecker.kt index b726e78e267..ca793a7a01d 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirUnsupportedArrayLiteralChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirUnsupportedArrayLiteralChecker.kt @@ -17,8 +17,8 @@ import org.jetbrains.kotlin.fir.declarations.impl.FirPrimaryConstructor import org.jetbrains.kotlin.fir.declarations.utils.isCompanion import org.jetbrains.kotlin.fir.expressions.* -object FirUnsupportedArrayLiteralChecker : FirArrayOfCallChecker() { - override fun check(expression: FirArrayOfCall, context: CheckerContext, reporter: DiagnosticReporter) { +object FirUnsupportedArrayLiteralChecker : FirArrayLiteralChecker() { + override fun check(expression: FirArrayLiteral, context: CheckerContext, reporter: DiagnosticReporter) { if (!isInsideAnnotationCall(expression, context) && (context.callsOrAssignments.isNotEmpty() || !isInsideAnnotationClass(context)) ) { @@ -31,7 +31,7 @@ object FirUnsupportedArrayLiteralChecker : FirArrayOfCallChecker() { } } - private fun isInsideAnnotationCall(expression: FirArrayOfCall, context: CheckerContext): Boolean { + private fun isInsideAnnotationCall(expression: FirArrayLiteral, context: CheckerContext): Boolean { context.callsOrAssignments.lastOrNull()?.let { val arguments = when (it) { is FirFunctionCall -> @@ -55,8 +55,8 @@ object FirUnsupportedArrayLiteralChecker : FirArrayOfCallChecker() { for (unwrapped in unwrappedArguments) { if (unwrapped == expression || (unwrapped is FirErrorExpression && unwrapped.expression == expression) || - unwrapped is FirArrayOfCall && - unwrapped.arguments.any { arrayOfCallElement -> arrayOfCallElement.unwrapArgument() == expression } + unwrapped is FirArrayLiteral && + unwrapped.arguments.any { arrayLiteralElement -> arrayLiteralElement.unwrapArgument() == expression } ) { return@any true } diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/components/ExpressionCheckersDiagnosticComponent.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/components/ExpressionCheckersDiagnosticComponent.kt index 65d8caebe18..a589a8f0576 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/components/ExpressionCheckersDiagnosticComponent.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/components/ExpressionCheckersDiagnosticComponent.kt @@ -118,8 +118,8 @@ class ExpressionCheckersDiagnosticComponent( checkers.allLogicExpressionCheckers.check(binaryLogicExpression, data) } - override fun visitArrayOfCall(arrayOfCall: FirArrayOfCall, data: CheckerContext) { - checkers.allArrayOfCallCheckers.check(arrayOfCall, data) + override fun visitArrayLiteral(arrayLiteral: FirArrayLiteral, data: CheckerContext) { + checkers.allArrayLiteralCheckers.check(arrayLiteral, data) } override fun visitStringConcatenationCall(stringConcatenationCall: FirStringConcatenationCall, data: CheckerContext) { diff --git a/compiler/fir/fir-deserialization/src/org/jetbrains/kotlin/fir/deserialization/AbstractAnnotationDeserializer.kt b/compiler/fir/fir-deserialization/src/org/jetbrains/kotlin/fir/deserialization/AbstractAnnotationDeserializer.kt index a2095e59c19..b516bcf9b7d 100644 --- a/compiler/fir/fir-deserialization/src/org/jetbrains/kotlin/fir/deserialization/AbstractAnnotationDeserializer.kt +++ b/compiler/fir/fir-deserialization/src/org/jetbrains/kotlin/fir/deserialization/AbstractAnnotationDeserializer.kt @@ -305,7 +305,7 @@ abstract class AbstractAnnotationDeserializer( } ARRAY -> { val expectedArrayElementType = expectedType()?.arrayElementType() ?: session.builtinTypes.anyType.type - buildArrayOfCall { + buildArrayLiteral { argumentList = buildArgumentList { value.arrayElementList.mapTo(arguments) { resolveValue(it, nameResolver) { expectedArrayElementType } } } diff --git a/compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/constant/FirToConstantValueTransformer.kt b/compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/constant/FirToConstantValueTransformer.kt index 241cb94b8f0..4a925ae1030 100644 --- a/compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/constant/FirToConstantValueTransformer.kt +++ b/compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/constant/FirToConstantValueTransformer.kt @@ -92,11 +92,11 @@ internal object FirToConstantValueTransformer : FirDefaultVisitor { - return ArrayValue(arrayOfCall.argumentList.arguments.mapNotNull { it.toConstantValue(data) }) + return ArrayValue(arrayLiteral.argumentList.arguments.mapNotNull { it.toConstantValue(data) }) } override fun visitAnnotation( @@ -207,9 +207,9 @@ internal object FirToConstantValueTransformer : FirDefaultVisitor { val arguments = varargArgumentsExpression.arguments.let { - // Named, spread or array literal arguments for vararg parameters have the form Vararg(Named/Spread?(ArrayOfCall(..))). - // We need to extract the ArrayOfCall, otherwise we will get two nested ArrayValue as a result. - (it.singleOrNull()?.unwrapArgument() as? FirArrayOfCall)?.arguments ?: it + // Named, spread or array literal arguments for vararg parameters have the form Vararg(Named/Spread?(ArrayLiteral(..))). + // We need to extract the ArrayLiteral, otherwise we will get two nested ArrayValue as a result. + (it.singleOrNull()?.unwrapArgument() as? FirArrayLiteral)?.arguments ?: it } return ArrayValue(arguments.mapNotNull { it.toConstantValue(data) }) @@ -246,8 +246,8 @@ internal object FirToConstantValueChecker : FirDefaultVisitor - val arrayType = arrayOfCall.typeRef.toIrType() - val elementType = if (arrayOfCall.typeRef is FirResolvedTypeRef) { + private fun convertToArrayLiteral(arrayLiteral: FirArrayLiteral): IrVararg { + return arrayLiteral.convertWithOffsets { startOffset, endOffset -> + val arrayType = arrayLiteral.typeRef.toIrType() + val elementType = if (arrayLiteral.typeRef is FirResolvedTypeRef) { arrayType.getArrayElementType(irBuiltIns) } else { createErrorType() @@ -1481,13 +1481,13 @@ class Fir2IrVisitor( startOffset, endOffset, type = arrayType, varargElementType = elementType, - elements = arrayOfCall.arguments.map { it.convertToIrVarargElement() } + elements = arrayLiteral.arguments.map { it.convertToIrVarargElement() } ) } } - override fun visitArrayOfCall(arrayOfCall: FirArrayOfCall, data: Any?): IrElement = whileAnalysing(session, arrayOfCall) { - return convertToArrayOfCall(arrayOfCall) + override fun visitArrayLiteral(arrayLiteral: FirArrayLiteral, data: Any?): IrElement = whileAnalysing(session, arrayLiteral) { + return convertToArrayLiteral(arrayLiteral) } override fun visitAugmentedArraySetCall( diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaUtils.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaUtils.kt index e59d319ba9a..2df3401108f 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaUtils.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaUtils.kt @@ -10,11 +10,10 @@ import org.jetbrains.kotlin.descriptors.Modality import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnostic import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind -import org.jetbrains.kotlin.fir.expressions.FirArrayOfCall -import org.jetbrains.kotlin.fir.expressions.FirConstExpression +import org.jetbrains.kotlin.fir.expressions.FirArrayLiteral import org.jetbrains.kotlin.fir.expressions.FirExpression import org.jetbrains.kotlin.fir.expressions.builder.buildArgumentList -import org.jetbrains.kotlin.fir.expressions.builder.buildArrayOfCall +import org.jetbrains.kotlin.fir.expressions.builder.buildArrayLiteral import org.jetbrains.kotlin.fir.expressions.builder.buildConstExpression import org.jetbrains.kotlin.fir.expressions.builder.buildErrorExpression import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.expectedConeType @@ -90,14 +89,14 @@ internal fun Any?.createConstantIfAny(session: FirSession, unsigned: Boolean = f is String -> buildConstExpression( null, ConstantValueKind.String, this, setType = true ) - is ByteArray -> toList().createArrayOfCall(session, ConstantValueKind.Byte) - is ShortArray -> toList().createArrayOfCall(session, ConstantValueKind.Short) - is IntArray -> toList().createArrayOfCall(session, ConstantValueKind.Int) - is LongArray -> toList().createArrayOfCall(session, ConstantValueKind.Long) - is CharArray -> toList().createArrayOfCall(session, ConstantValueKind.Char) - is FloatArray -> toList().createArrayOfCall(session, ConstantValueKind.Float) - is DoubleArray -> toList().createArrayOfCall(session, ConstantValueKind.Double) - is BooleanArray -> toList().createArrayOfCall(session, ConstantValueKind.Boolean) + is ByteArray -> toList().createArrayLiteral(session, ConstantValueKind.Byte) + is ShortArray -> toList().createArrayLiteral(session, ConstantValueKind.Short) + is IntArray -> toList().createArrayLiteral(session, ConstantValueKind.Int) + is LongArray -> toList().createArrayLiteral(session, ConstantValueKind.Long) + is CharArray -> toList().createArrayLiteral(session, ConstantValueKind.Char) + is FloatArray -> toList().createArrayLiteral(session, ConstantValueKind.Float) + is DoubleArray -> toList().createArrayLiteral(session, ConstantValueKind.Double) + is BooleanArray -> toList().createArrayLiteral(session, ConstantValueKind.Boolean) null -> buildConstExpression( null, ConstantValueKind.Null, null, setType = true ) @@ -106,10 +105,10 @@ internal fun Any?.createConstantIfAny(session: FirSession, unsigned: Boolean = f } } -private fun List.createArrayOfCall(session: FirSession, kind: ConstantValueKind): FirArrayOfCall { - return buildArrayOfCall { +private fun List.createArrayLiteral(session: FirSession, kind: ConstantValueKind): FirArrayLiteral { + return buildArrayLiteral { argumentList = buildArgumentList { - for (element in this@createArrayOfCall) { + for (element in this@createArrayLiteral) { arguments += element.createConstantOrError(session) } } diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/deserialization/AnnotationsLoader.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/deserialization/AnnotationsLoader.kt index 8fb703a6d50..d2d72d70f6f 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/deserialization/AnnotationsLoader.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/deserialization/AnnotationsLoader.kt @@ -94,7 +94,7 @@ internal class AnnotationsLoader(private val session: FirSession, private val ko } override fun visitEnd() { - visitExpression(name, buildArrayOfCall { + visitExpression(name, buildArrayLiteral { guessArrayTypeIfNeeded(name, elements)?.let { typeRef = it } ?: elements.firstOrNull()?.typeRef?.coneType?.createOutArrayType()?.let { diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/FirAnnotationTypeQualifierResolver.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/FirAnnotationTypeQualifierResolver.kt index 0e865e6a8c4..e72d4bdcc86 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/FirAnnotationTypeQualifierResolver.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/FirAnnotationTypeQualifierResolver.kt @@ -48,7 +48,7 @@ class FirAnnotationTypeQualifierResolver( private fun FirExpression.toEnumNames(): List = when (this) { - is FirArrayOfCall -> arguments.flatMap { it.toEnumNames() } + is FirArrayLiteral -> arguments.flatMap { it.toEnumNames() } is FirVarargArgumentsExpression -> arguments.flatMap { it.toEnumNames() } else -> { val name = when (val reference = toReference()) { diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/javaAnnotationsMapping.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/javaAnnotationsMapping.kt index 8ec6c24fe7c..e60f56df945 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/javaAnnotationsMapping.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/javaAnnotationsMapping.kt @@ -15,11 +15,7 @@ import org.jetbrains.kotlin.fir.declarations.FirRegularClass import org.jetbrains.kotlin.fir.declarations.FirValueParameter import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnostic import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind -import org.jetbrains.kotlin.fir.expressions.FirAnnotation -import org.jetbrains.kotlin.fir.expressions.FirAnnotationArgumentMapping -import org.jetbrains.kotlin.fir.expressions.FirExpression -import org.jetbrains.kotlin.fir.expressions.FirPropertyAccessExpression -import org.jetbrains.kotlin.fir.expressions.buildUnaryArgumentList +import org.jetbrains.kotlin.fir.expressions.* import org.jetbrains.kotlin.fir.expressions.builder.* import org.jetbrains.kotlin.fir.java.declarations.buildJavaValueParameter import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference @@ -89,7 +85,7 @@ internal fun JavaAnnotationArgument.toFirExpression( ): FirExpression { return when (this) { is JavaLiteralAnnotationArgument -> value.createConstantOrError(session) - is JavaArrayAnnotationArgument -> buildArrayOfCall { + is JavaArrayAnnotationArgument -> buildArrayLiteral { val argumentTypeRef = expectedTypeRef?.let { typeRef = if (it is FirJavaTypeRef) buildResolvedTypeRef { type = it.toConeKotlinTypeProbablyFlexible(session, javaTypeParameterStack) diff --git a/compiler/fir/providers/src/org/jetbrains/kotlin/fir/declarations/FirAnnotationUtils.kt b/compiler/fir/providers/src/org/jetbrains/kotlin/fir/declarations/FirAnnotationUtils.kt index 9ac03fc9963..8e09f82ab15 100644 --- a/compiler/fir/providers/src/org/jetbrains/kotlin/fir/declarations/FirAnnotationUtils.kt +++ b/compiler/fir/providers/src/org/jetbrains/kotlin/fir/declarations/FirAnnotationUtils.kt @@ -201,7 +201,7 @@ inline fun List.mapAnnotationsWithClassIdTo( fun FirExpression.unwrapVarargValue(): List { return when (this) { is FirVarargArgumentsExpression -> arguments - is FirArrayOfCall -> arguments + is FirArrayLiteral -> arguments else -> listOf(this) } } @@ -224,7 +224,7 @@ fun FirAnnotation.findArgumentByName(name: Name): FirExpression? { fun FirAnnotation.getBooleanArgument(name: Name): Boolean? = getPrimitiveArgumentValue(name) fun FirAnnotation.getStringArgument(name: Name): String? = getPrimitiveArgumentValue(name) fun FirAnnotation.getStringArrayArgument(name: Name): List? { - val argument = findArgumentByName(name) as? FirArrayOfCall ?: return null + val argument = findArgumentByName(name) as? FirArrayLiteral ?: return null return argument.arguments.mapNotNull { (it as? FirConstExpression<*>)?.value as? String } } diff --git a/compiler/fir/providers/src/org/jetbrains/kotlin/fir/types/ConeTypeContext.kt b/compiler/fir/providers/src/org/jetbrains/kotlin/fir/types/ConeTypeContext.kt index 32bcb2c4ce8..4f36dc5f5b5 100644 --- a/compiler/fir/providers/src/org/jetbrains/kotlin/fir/types/ConeTypeContext.kt +++ b/compiler/fir/providers/src/org/jetbrains/kotlin/fir/types/ConeTypeContext.kt @@ -562,7 +562,7 @@ interface ConeTypeContext : TypeSystemContext, TypeSystemOptimizationContext, Ty } ?: return null val argument = when (val argument = annotationCall.argumentMapping.mapping.values.firstOrNull() ?: return null) { is FirVarargArgumentsExpression -> argument.arguments.firstOrNull() - is FirArrayOfCall -> argument.arguments.firstOrNull() + is FirArrayLiteral -> argument.arguments.firstOrNull() is FirNamedArgumentExpression -> argument.expression else -> argument } ?: return null diff --git a/compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/converter/LightTreeRawFirExpressionBuilder.kt b/compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/converter/LightTreeRawFirExpressionBuilder.kt index 5d2b71ab84c..395fc3552a2 100644 --- a/compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/converter/LightTreeRawFirExpressionBuilder.kt +++ b/compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/converter/LightTreeRawFirExpressionBuilder.kt @@ -988,7 +988,7 @@ class LightTreeRawFirExpressionBuilder( if (it.isExpression()) firExpressionList += getAsFirExpression(it, "Incorrect collection literal argument") } - return buildArrayOfCall { + return buildArrayLiteral { source = expression.toFirSourceElement() argumentList = buildArgumentList { arguments += firExpressionList diff --git a/compiler/fir/raw-fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/PsiRawFirBuilder.kt b/compiler/fir/raw-fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/PsiRawFirBuilder.kt index f378a3caf0f..9940aec8df8 100644 --- a/compiler/fir/raw-fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/PsiRawFirBuilder.kt +++ b/compiler/fir/raw-fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/PsiRawFirBuilder.kt @@ -2953,7 +2953,7 @@ open class PsiRawFirBuilder( } override fun visitCollectionLiteralExpression(expression: KtCollectionLiteralExpression, data: FirElement?): FirElement { - return buildArrayOfCall { + return buildArrayLiteral { source = expression.toFirSourceElement() argumentList = buildArgumentList { for (innerExpression in expression.getInnerExpressions()) { 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 ba6f8e664f5..a4de823f3fb 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirCallResolver.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirCallResolver.kt @@ -542,7 +542,7 @@ class FirCallResolver( annotation.replaceArgumentList(buildArgumentList { source = annotation.argumentList.source annotation.arguments.mapTo(arguments) { arg -> - val resolutionMode = if (arg.unwrapArgument() is FirArrayOfCall) { + val resolutionMode = if (arg.unwrapArgument() is FirArrayLiteral) { (argumentsToParameters[arg]?.returnTypeRef as? FirResolvedTypeRef)?.let { // Enabling expectedTypeMismatchIsReportedInChecker clarifies error messages: // It will be reported single ARGUMENT_TYPE_MISMATCH on the array literal in checkApplicabilityForArgumentType 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 2f25c48ad4a..63e667e507c 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 @@ -774,20 +774,20 @@ class FirCallCompletionResultsWriterTransformer( return integerLiteralOperatorCall.transformSingle(integerOperatorApproximator, expectedType) } - override fun transformArrayOfCall(arrayOfCall: FirArrayOfCall, data: ExpectedArgumentType?): FirStatement { - if (arrayOfCall.typeRef !is FirImplicitTypeRef) return arrayOfCall - val expectedArrayType = data?.getExpectedType(arrayOfCall) + override fun transformArrayLiteral(arrayLiteral: FirArrayLiteral, data: ExpectedArgumentType?): FirStatement { + if (arrayLiteral.typeRef !is FirImplicitTypeRef) return arrayLiteral + val expectedArrayType = data?.getExpectedType(arrayLiteral) val expectedArrayElementType = expectedArrayType?.arrayElementType() - arrayOfCall.transformChildren(this, expectedArrayElementType?.toExpectedType()) + arrayLiteral.transformChildren(this, expectedArrayElementType?.toExpectedType()) val arrayElementType = - session.typeContext.commonSuperTypeOrNull(arrayOfCall.arguments.map { it.typeRef.coneType })?.let { + session.typeContext.commonSuperTypeOrNull(arrayLiteral.arguments.map { it.typeRef.coneType })?.let { typeApproximator.approximateToSuperType(it, TypeApproximatorConfiguration.FinalApproximationAfterResolutionAndInference) ?: it } ?: expectedArrayElementType ?: session.builtinTypes.nullableAnyType.type - arrayOfCall.resultType = arrayOfCall.typeRef.resolvedTypeFromPrototype( + arrayLiteral.resultType = arrayLiteral.typeRef.resolvedTypeFromPrototype( arrayElementType.createArrayType(createPrimitiveArrayTypeIfPossible = expectedArrayType?.isPrimitiveArray == true) ) - return arrayOfCall + return arrayLiteral } override fun transformVarargArgumentsExpression( diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSyntheticCallGenerator.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSyntheticCallGenerator.kt index 727d47045df..4700ba2f4c5 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSyntheticCallGenerator.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSyntheticCallGenerator.kt @@ -148,14 +148,14 @@ class FirSyntheticCallGenerator( return elvisExpression.transformCalleeReference(UpdateReference, reference) } - fun generateSyntheticIdCall(arrayOfCall: FirExpression, context: ResolutionContext): FirFunctionCall { + fun generateSyntheticIdCall(arrayLiteral: FirExpression, context: ResolutionContext): FirFunctionCall { val argumentList = buildArgumentList { - arguments += arrayOfCall + arguments += arrayLiteral } return buildFunctionCall { this.argumentList = argumentList calleeReference = generateCalleeReferenceWithCandidate( - arrayOfCall, + arrayLiteral, idFunction, argumentList, SyntheticCallableId.ID.callableName, @@ -165,22 +165,22 @@ class FirSyntheticCallGenerator( } fun generateSyntheticArrayOfCall( - arrayOfCall: FirArrayOfCall, + arrayLiteral: FirArrayLiteral, expectedTypeRef: FirTypeRef, context: ResolutionContext ): FirFunctionCall { - val argumentList = arrayOfCall.argumentList + val argumentList = arrayLiteral.argumentList return buildFunctionCall { this.argumentList = argumentList calleeReference = generateCalleeReferenceWithCandidate( - arrayOfCall, + arrayLiteral, calculateArrayOfSymbol(expectedTypeRef).fir, argumentList, ArrayFqNames.ARRAY_OF_FUNCTION, callKind = CallKind.Function, context = context, ) - source = arrayOfCall.source + source = arrayLiteral.source } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirAbstractBodyResolveTransformerDispatcher.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirAbstractBodyResolveTransformerDispatcher.kt index 7db4b72cc64..51b4c51b7f1 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirAbstractBodyResolveTransformerDispatcher.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirAbstractBodyResolveTransformerDispatcher.kt @@ -5,12 +5,9 @@ package org.jetbrains.kotlin.fir.resolve.transformers.body.resolve -import org.jetbrains.kotlin.fir.FirElement -import org.jetbrains.kotlin.fir.FirSession -import org.jetbrains.kotlin.fir.FirTargetElement +import org.jetbrains.kotlin.fir.* import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.expressions.* -import org.jetbrains.kotlin.fir.render import org.jetbrains.kotlin.fir.resolve.ResolutionMode import org.jetbrains.kotlin.fir.resolve.ScopeSession import org.jetbrains.kotlin.fir.resolve.calls.ResolutionContext @@ -21,7 +18,6 @@ import org.jetbrains.kotlin.fir.resolve.transformers.ReturnTypeCalculatorForFull import org.jetbrains.kotlin.fir.resolve.transformers.ScopeClassDeclaration import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.fir.visitors.FirTransformer -import org.jetbrains.kotlin.fir.withFileAnalysisExceptionWrapping abstract class FirAbstractBodyResolveTransformerDispatcher( session: FirSession, @@ -281,8 +277,8 @@ abstract class FirAbstractBodyResolveTransformerDispatcher( return expressionsTransformer.transformCheckedSafeCallSubject(checkedSafeCallSubject, data) } - override fun transformArrayOfCall(arrayOfCall: FirArrayOfCall, data: ResolutionMode): FirStatement { - return expressionsTransformer.transformArrayOfCall(arrayOfCall, data) + override fun transformArrayLiteral(arrayLiteral: FirArrayLiteral, data: ResolutionMode): FirStatement { + return expressionsTransformer.transformArrayLiteral(arrayLiteral, data) } override fun transformSmartCastExpression(smartCastExpression: FirSmartCastExpression, data: ResolutionMode): FirStatement { diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirArrayOfCallTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirArrayOfCallTransformer.kt index 11111d89087..752a519bb69 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirArrayOfCallTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirArrayOfCallTransformer.kt @@ -13,7 +13,7 @@ import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction import org.jetbrains.kotlin.fir.expressions.* import org.jetbrains.kotlin.fir.expressions.builder.buildArgumentList -import org.jetbrains.kotlin.fir.expressions.builder.buildArrayOfCall +import org.jetbrains.kotlin.fir.expressions.builder.buildArrayLiteral import org.jetbrains.kotlin.fir.references.FirResolvedErrorReference import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference import org.jetbrains.kotlin.fir.references.isError @@ -26,15 +26,15 @@ import org.jetbrains.kotlin.fir.types.isArrayType import org.jetbrains.kotlin.fir.visitors.FirDefaultTransformer /** - * A transformer that converts resolved arrayOf() call to [FirArrayOfCall]. + * A transformer that converts resolved arrayOf() call to [FirArrayLiteral]. * * Note that arrayOf() calls only in [FirAnnotation] or the default value of annotation constructor are transformed. */ class FirArrayOfCallTransformer : FirDefaultTransformer() { - private fun toArrayOfCall(functionCall: FirFunctionCall, session: FirSession): FirExpression? { + private fun toArrayLiteral(functionCall: FirFunctionCall, session: FirSession): FirExpression? { if (!functionCall.isArrayOfCall(session)) return null if (functionCall.calleeReference !is FirResolvedNamedReference) return null - val arrayOfCall = buildArrayOfCall { + val arrayLiteral = buildArrayLiteral { source = functionCall.source annotations += functionCall.annotations // Note that the signature is: arrayOf(vararg element). Hence, unwrapping the original argument list here. @@ -54,16 +54,16 @@ class FirArrayOfCallTransformer : FirDefaultTransformer() { buildErrorExpression( functionCall.source?.fakeElement(KtFakeSourceElementKind.ErrorTypeRef), calleeReference.diagnostic, - arrayOfCall + arrayLiteral ) } else { - arrayOfCall + arrayLiteral } } override fun transformFunctionCall(functionCall: FirFunctionCall, data: FirSession): FirStatement { functionCall.transformChildren(this, data) - return toArrayOfCall(functionCall, data) ?: functionCall + return toArrayLiteral(functionCall, data) ?: functionCall } override fun transformElement(element: E, data: FirSession): E { 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 1a9b0a55050..eed340b867a 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 @@ -1631,28 +1631,28 @@ open class FirExpressionsResolveTransformer(transformer: FirAbstractBodyResolveT ) } - override fun transformArrayLiteral(arrayOfCall: FirArrayOfCall, data: ResolutionMode): FirStatement = - whileAnalysing(session, arrayOfCall) { + override fun transformArrayLiteral(arrayLiteral: FirArrayLiteral, data: ResolutionMode): FirStatement = + whileAnalysing(session, arrayLiteral) { when (data) { is ResolutionMode.ContextDependent.Default -> { // Argument in non-annotation call (unsupported) or if type of array parameter is unresolved. - arrayOfCall.transformChildren(transformer, data) - arrayOfCall + arrayLiteral.transformChildren(transformer, data) + arrayLiteral } is ResolutionMode.WithExpectedType -> { // Default value of array parameter (Array or primitive array such as IntArray, FloatArray, ...) // or argument for array parameter in annotation call. - arrayOfCall.transformChildren(transformer, ResolutionMode.ContextDependent) - val call = components.syntheticCallGenerator.generateSyntheticArrayOfCall(arrayOfCall, data.expectedTypeRef, resolutionContext) + arrayLiteral.transformChildren(transformer, ResolutionMode.ContextDependent) + val call = components.syntheticCallGenerator.generateSyntheticArrayOfCall(arrayLiteral, data.expectedTypeRef, resolutionContext) callCompleter.completeCall(call, data) arrayOfCallTransformer.transformFunctionCall(call, session) } else -> { // Other unsupported usage. - val syntheticIdCall = components.syntheticCallGenerator.generateSyntheticIdCall(arrayOfCall, resolutionContext) - arrayOfCall.transformChildren(transformer, ResolutionMode.ContextDependent) + val syntheticIdCall = components.syntheticCallGenerator.generateSyntheticIdCall(arrayLiteral, resolutionContext) + arrayLiteral.transformChildren(transformer, ResolutionMode.ContextDependent) callCompleter.completeCall(syntheticIdCall, data) - arrayOfCall + arrayLiteral } } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirAnnotationArgumentsResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirAnnotationArgumentsResolveTransformer.kt index 131cbf95c31..782b0f0bb47 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirAnnotationArgumentsResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirAnnotationArgumentsResolveTransformer.kt @@ -19,16 +19,12 @@ import org.jetbrains.kotlin.fir.references.builder.buildSimpleNamedReference import org.jetbrains.kotlin.fir.references.toResolvedBaseSymbol import org.jetbrains.kotlin.fir.resolve.ResolutionMode import org.jetbrains.kotlin.fir.resolve.ScopeSession +import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeAmbiguouslyResolvedAnnotationArgument import org.jetbrains.kotlin.fir.resolve.transformers.ReturnTypeCalculator import org.jetbrains.kotlin.fir.resolve.transformers.ReturnTypeCalculatorForFullBodyResolve -import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.BodyResolveContext -import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirAbstractBodyResolveTransformerDispatcher -import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirDeclarationsResolveTransformer -import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirExpressionsResolveTransformer -import org.jetbrains.kotlin.fir.visitors.transformSingle -import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeAmbiguouslyResolvedAnnotationArgument -import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirResolveContextCollector +import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.* import org.jetbrains.kotlin.fir.symbols.impl.FirEnumEntrySymbol +import org.jetbrains.kotlin.fir.visitors.transformSingle import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.StandardClassIds @@ -275,9 +271,9 @@ abstract class AbstractFirExpressionsResolveTransformerForAnnotations(transforme return augmentedArraySetCall } - override fun transformArrayOfCall(arrayOfCall: FirArrayOfCall, data: ResolutionMode): FirStatement { - arrayOfCall.transformChildren(transformer, data) - return arrayOfCall + override fun transformArrayLiteral(arrayLiteral: FirArrayLiteral, data: ResolutionMode): FirStatement { + arrayLiteral.transformChildren(transformer, data) + return arrayLiteral } override fun shouldComputeTypeOfGetClassCallWithNotQualifierInLhs(getClassCall: FirGetClassCall): Boolean { diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/FirArrayOfCall.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/FirArrayLiteral.kt similarity index 85% rename from compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/FirArrayOfCall.kt rename to compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/FirArrayLiteral.kt index 89b9a87512b..da4f2586ee0 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/FirArrayOfCall.kt +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/FirArrayLiteral.kt @@ -15,17 +15,17 @@ import org.jetbrains.kotlin.fir.visitors.* * DO NOT MODIFY IT MANUALLY */ -abstract class FirArrayOfCall : FirExpression(), FirCall { +abstract class FirArrayLiteral : FirExpression(), FirCall { abstract override val source: KtSourceElement? abstract override val typeRef: FirTypeRef abstract override val annotations: List abstract override val argumentList: FirArgumentList - override fun accept(visitor: FirVisitor, data: D): R = visitor.visitArrayOfCall(this, data) + override fun accept(visitor: FirVisitor, data: D): R = visitor.visitArrayLiteral(this, data) @Suppress("UNCHECKED_CAST") override fun transform(transformer: FirTransformer, data: D): E = - transformer.transformArrayOfCall(this, data) as E + transformer.transformArrayLiteral(this, data) as E abstract override fun replaceTypeRef(newTypeRef: FirTypeRef) @@ -33,5 +33,5 @@ abstract class FirArrayOfCall : FirExpression(), FirCall { abstract override fun replaceArgumentList(newArgumentList: FirArgumentList) - abstract override fun transformAnnotations(transformer: FirTransformer, data: D): FirArrayOfCall + abstract override fun transformAnnotations(transformer: FirTransformer, data: D): FirArrayLiteral } diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/builder/FirArrayOfCallBuilder.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/builder/FirArrayLiteralBuilder.kt similarity index 77% rename from compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/builder/FirArrayOfCallBuilder.kt rename to compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/builder/FirArrayLiteralBuilder.kt index d0d1495b9e7..af8260a36cc 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/builder/FirArrayOfCallBuilder.kt +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/builder/FirArrayLiteralBuilder.kt @@ -14,10 +14,10 @@ import org.jetbrains.kotlin.fir.builder.FirBuilderDsl import org.jetbrains.kotlin.fir.builder.toMutableOrEmpty import org.jetbrains.kotlin.fir.expressions.FirAnnotation import org.jetbrains.kotlin.fir.expressions.FirArgumentList -import org.jetbrains.kotlin.fir.expressions.FirArrayOfCall +import org.jetbrains.kotlin.fir.expressions.FirArrayLiteral import org.jetbrains.kotlin.fir.expressions.builder.FirCallBuilder import org.jetbrains.kotlin.fir.expressions.builder.FirExpressionBuilder -import org.jetbrains.kotlin.fir.expressions.impl.FirArrayOfCallImpl +import org.jetbrains.kotlin.fir.expressions.impl.FirArrayLiteralImpl import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.fir.types.impl.FirImplicitTypeRefImplWithoutSource import org.jetbrains.kotlin.fir.visitors.* @@ -28,14 +28,14 @@ import org.jetbrains.kotlin.fir.visitors.* */ @FirBuilderDsl -class FirArrayOfCallBuilder : FirCallBuilder, FirAnnotationContainerBuilder, FirExpressionBuilder { +class FirArrayLiteralBuilder : FirCallBuilder, FirAnnotationContainerBuilder, FirExpressionBuilder { override var source: KtSourceElement? = null override var typeRef: FirTypeRef = FirImplicitTypeRefImplWithoutSource override val annotations: MutableList = mutableListOf() override lateinit var argumentList: FirArgumentList - override fun build(): FirArrayOfCall { - return FirArrayOfCallImpl( + override fun build(): FirArrayLiteral { + return FirArrayLiteralImpl( source, typeRef, annotations.toMutableOrEmpty(), @@ -46,9 +46,9 @@ class FirArrayOfCallBuilder : FirCallBuilder, FirAnnotationContainerBuilder, Fir } @OptIn(ExperimentalContracts::class) -inline fun buildArrayOfCall(init: FirArrayOfCallBuilder.() -> Unit): FirArrayOfCall { +inline fun buildArrayLiteral(init: FirArrayLiteralBuilder.() -> Unit): FirArrayLiteral { contract { callsInPlace(init, kotlin.contracts.InvocationKind.EXACTLY_ONCE) } - return FirArrayOfCallBuilder().apply(init).build() + return FirArrayLiteralBuilder().apply(init).build() } diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/impl/FirArrayOfCallImpl.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/impl/FirArrayLiteralImpl.kt similarity index 90% rename from compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/impl/FirArrayOfCallImpl.kt rename to compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/impl/FirArrayLiteralImpl.kt index 13c5e3aeb08..4e0f5f2a570 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/impl/FirArrayOfCallImpl.kt +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/impl/FirArrayLiteralImpl.kt @@ -10,7 +10,7 @@ package org.jetbrains.kotlin.fir.expressions.impl import org.jetbrains.kotlin.KtSourceElement import org.jetbrains.kotlin.fir.expressions.FirAnnotation import org.jetbrains.kotlin.fir.expressions.FirArgumentList -import org.jetbrains.kotlin.fir.expressions.FirArrayOfCall +import org.jetbrains.kotlin.fir.expressions.FirArrayLiteral import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.fir.visitors.* import org.jetbrains.kotlin.fir.MutableOrEmptyList @@ -21,26 +21,26 @@ import org.jetbrains.kotlin.fir.builder.toMutableOrEmpty * DO NOT MODIFY IT MANUALLY */ -internal class FirArrayOfCallImpl( +internal class FirArrayLiteralImpl( override val source: KtSourceElement?, override var typeRef: FirTypeRef, override var annotations: MutableOrEmptyList, override var argumentList: FirArgumentList, -) : FirArrayOfCall() { +) : FirArrayLiteral() { override fun acceptChildren(visitor: FirVisitor, data: D) { typeRef.accept(visitor, data) annotations.forEach { it.accept(visitor, data) } argumentList.accept(visitor, data) } - override fun transformChildren(transformer: FirTransformer, data: D): FirArrayOfCallImpl { + override fun transformChildren(transformer: FirTransformer, data: D): FirArrayLiteralImpl { typeRef = typeRef.transform(transformer, data) transformAnnotations(transformer, data) argumentList = argumentList.transform(transformer, data) return this } - override fun transformAnnotations(transformer: FirTransformer, data: D): FirArrayOfCallImpl { + override fun transformAnnotations(transformer: FirTransformer, data: D): FirArrayLiteralImpl { annotations.transformInplace(transformer, data) return this } diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirDefaultVisitor.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirDefaultVisitor.kt index 1a4ec5fa4ac..e33413bfd75 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirDefaultVisitor.kt +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirDefaultVisitor.kt @@ -94,7 +94,7 @@ import org.jetbrains.kotlin.fir.expressions.FirWhenBranch import org.jetbrains.kotlin.fir.expressions.FirContextReceiverArgumentListOwner import org.jetbrains.kotlin.fir.expressions.FirCheckNotNullCall import org.jetbrains.kotlin.fir.expressions.FirElvisExpression -import org.jetbrains.kotlin.fir.expressions.FirArrayOfCall +import org.jetbrains.kotlin.fir.expressions.FirArrayLiteral import org.jetbrains.kotlin.fir.expressions.FirAugmentedArraySetCall import org.jetbrains.kotlin.fir.expressions.FirClassReferenceExpression import org.jetbrains.kotlin.fir.expressions.FirErrorExpression diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirDefaultVisitorVoid.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirDefaultVisitorVoid.kt index 1a2d56db2ef..cd68a2bf5fc 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirDefaultVisitorVoid.kt +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirDefaultVisitorVoid.kt @@ -94,7 +94,7 @@ import org.jetbrains.kotlin.fir.expressions.FirWhenBranch import org.jetbrains.kotlin.fir.expressions.FirContextReceiverArgumentListOwner import org.jetbrains.kotlin.fir.expressions.FirCheckNotNullCall import org.jetbrains.kotlin.fir.expressions.FirElvisExpression -import org.jetbrains.kotlin.fir.expressions.FirArrayOfCall +import org.jetbrains.kotlin.fir.expressions.FirArrayLiteral import org.jetbrains.kotlin.fir.expressions.FirAugmentedArraySetCall import org.jetbrains.kotlin.fir.expressions.FirClassReferenceExpression import org.jetbrains.kotlin.fir.expressions.FirErrorExpression 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 5e5b4112dcf..981469f4933 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 @@ -94,7 +94,7 @@ import org.jetbrains.kotlin.fir.expressions.FirWhenBranch import org.jetbrains.kotlin.fir.expressions.FirContextReceiverArgumentListOwner import org.jetbrains.kotlin.fir.expressions.FirCheckNotNullCall import org.jetbrains.kotlin.fir.expressions.FirElvisExpression -import org.jetbrains.kotlin.fir.expressions.FirArrayOfCall +import org.jetbrains.kotlin.fir.expressions.FirArrayLiteral import org.jetbrains.kotlin.fir.expressions.FirAugmentedArraySetCall import org.jetbrains.kotlin.fir.expressions.FirClassReferenceExpression import org.jetbrains.kotlin.fir.expressions.FirErrorExpression @@ -522,8 +522,8 @@ abstract class FirTransformer : FirVisitor() { return transformElement(elvisExpression, data) } - open fun transformArrayOfCall(arrayOfCall: FirArrayOfCall, data: D): FirStatement { - return transformElement(arrayOfCall, data) + open fun transformArrayLiteral(arrayLiteral: FirArrayLiteral, data: D): FirStatement { + return transformElement(arrayLiteral, data) } open fun transformAugmentedArraySetCall(augmentedArraySetCall: FirAugmentedArraySetCall, data: D): FirStatement { @@ -1142,8 +1142,8 @@ abstract class FirTransformer : FirVisitor() { return transformElvisExpression(elvisExpression, data) } - final override fun visitArrayOfCall(arrayOfCall: FirArrayOfCall, data: D): FirStatement { - return transformArrayOfCall(arrayOfCall, data) + final override fun visitArrayLiteral(arrayLiteral: FirArrayLiteral, data: D): FirStatement { + return transformArrayLiteral(arrayLiteral, data) } final override fun visitAugmentedArraySetCall(augmentedArraySetCall: FirAugmentedArraySetCall, data: D): FirStatement { 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 747a163c131..adfb3d8bd05 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 @@ -94,7 +94,7 @@ import org.jetbrains.kotlin.fir.expressions.FirWhenBranch import org.jetbrains.kotlin.fir.expressions.FirContextReceiverArgumentListOwner import org.jetbrains.kotlin.fir.expressions.FirCheckNotNullCall import org.jetbrains.kotlin.fir.expressions.FirElvisExpression -import org.jetbrains.kotlin.fir.expressions.FirArrayOfCall +import org.jetbrains.kotlin.fir.expressions.FirArrayLiteral import org.jetbrains.kotlin.fir.expressions.FirAugmentedArraySetCall import org.jetbrains.kotlin.fir.expressions.FirClassReferenceExpression import org.jetbrains.kotlin.fir.expressions.FirErrorExpression @@ -345,7 +345,7 @@ abstract class FirVisitor { open fun visitElvisExpression(elvisExpression: FirElvisExpression, data: D): R = visitElement(elvisExpression, data) - open fun visitArrayOfCall(arrayOfCall: FirArrayOfCall, data: D): R = visitElement(arrayOfCall, data) + open fun visitArrayLiteral(arrayLiteral: FirArrayLiteral, data: D): R = visitElement(arrayLiteral, data) open fun visitAugmentedArraySetCall(augmentedArraySetCall: FirAugmentedArraySetCall, data: D): R = visitElement(augmentedArraySetCall, 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 379feaa2828..65caf749d51 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 @@ -94,7 +94,7 @@ import org.jetbrains.kotlin.fir.expressions.FirWhenBranch import org.jetbrains.kotlin.fir.expressions.FirContextReceiverArgumentListOwner import org.jetbrains.kotlin.fir.expressions.FirCheckNotNullCall import org.jetbrains.kotlin.fir.expressions.FirElvisExpression -import org.jetbrains.kotlin.fir.expressions.FirArrayOfCall +import org.jetbrains.kotlin.fir.expressions.FirArrayLiteral import org.jetbrains.kotlin.fir.expressions.FirAugmentedArraySetCall import org.jetbrains.kotlin.fir.expressions.FirClassReferenceExpression import org.jetbrains.kotlin.fir.expressions.FirErrorExpression @@ -521,8 +521,8 @@ abstract class FirVisitorVoid : FirVisitor() { visitElement(elvisExpression) } - open fun visitArrayOfCall(arrayOfCall: FirArrayOfCall) { - visitElement(arrayOfCall) + open fun visitArrayLiteral(arrayLiteral: FirArrayLiteral) { + visitElement(arrayLiteral) } open fun visitAugmentedArraySetCall(augmentedArraySetCall: FirAugmentedArraySetCall) { @@ -1141,8 +1141,8 @@ abstract class FirVisitorVoid : FirVisitor() { visitElvisExpression(elvisExpression) } - final override fun visitArrayOfCall(arrayOfCall: FirArrayOfCall, data: Nothing?) { - visitArrayOfCall(arrayOfCall) + final override fun visitArrayLiteral(arrayLiteral: FirArrayLiteral, data: Nothing?) { + visitArrayLiteral(arrayLiteral) } final override fun visitAugmentedArraySetCall(augmentedArraySetCall: FirAugmentedArraySetCall, data: Nothing?) { diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirExpressionUtil.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirExpressionUtil.kt index 352a4f60ffa..56bbbb5e369 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirExpressionUtil.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirExpressionUtil.kt @@ -130,7 +130,7 @@ fun FirExpression.unwrapAndFlattenArgument(): List = buildList { private fun FirExpression.unwrapAndFlattenArgumentTo(list: MutableList) { when (val unwrapped = unwrapArgument()) { - is FirArrayOfCall, is FirFunctionCall -> (unwrapped as FirCall).arguments.forEach { it.unwrapAndFlattenArgumentTo(list) } + is FirArrayLiteral, is FirFunctionCall -> (unwrapped as FirCall).arguments.forEach { it.unwrapAndFlattenArgumentTo(list) } is FirVarargArgumentsExpression -> unwrapped.arguments.forEach { it.unwrapAndFlattenArgumentTo(list) } else -> list.add(unwrapped) } diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/renderer/FirRenderer.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/renderer/FirRenderer.kt index c8bc3cd1659..1dd461e9608 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/renderer/FirRenderer.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/renderer/FirRenderer.kt @@ -5,8 +5,8 @@ package org.jetbrains.kotlin.fir.renderer -import org.jetbrains.kotlin.builtins.functions.FunctionTypeKindExtractor import org.jetbrains.kotlin.builtins.functions.AllowedToUsedOnlyInK1 +import org.jetbrains.kotlin.builtins.functions.FunctionTypeKindExtractor import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget import org.jetbrains.kotlin.fir.* import org.jetbrains.kotlin.fir.contracts.FirContractDescription @@ -1110,10 +1110,10 @@ class FirRenderer( print(")") } - override fun visitArrayOfCall(arrayOfCall: FirArrayOfCall) { - annotationRenderer?.render(arrayOfCall) + override fun visitArrayLiteral(arrayLiteral: FirArrayLiteral) { + annotationRenderer?.render(arrayLiteral) print("") - visitCall(arrayOfCall) + visitCall(arrayLiteral) } override fun visitThrowExpression(throwExpression: FirThrowExpression) { diff --git a/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/BuilderConfigurator.kt b/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/BuilderConfigurator.kt index ffe8b21d4d7..c6cf7c4269c 100644 --- a/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/BuilderConfigurator.kt +++ b/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/BuilderConfigurator.kt @@ -151,7 +151,7 @@ object BuilderConfigurator : AbstractBuilderConfigurator(FirTree useTypes(emptyArgumentListType, emptyAnnotationArgumentMappingType, firImplicitTypeWithoutSourceType) } - builder(arrayOfCall) { + builder(arrayLiteral) { parents += callBuilder } @@ -418,7 +418,7 @@ object BuilderConfigurator : AbstractBuilderConfigurator(FirTree varargArgumentsExpression, checkedSafeCallSubject, safeCallExpression, - arrayOfCall, + arrayLiteral, classReferenceExpression, getClassCall ) 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 3596c91f474..7f2828c5adf 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 @@ -118,7 +118,7 @@ object FirTreeBuilder : AbstractFirTreeBuilder() { val checkNotNullCall by element(Expression, expression, call, resolvable) val elvisExpression by element(Expression, expression, resolvable) - val arrayOfCall by element(Expression, expression, call) + val arrayLiteral by element(Expression, expression, call) val augmentedArraySetCall by element(Expression, statement) val classReferenceExpression by element(Expression, expression) val errorExpression by element(Expression, expression, diagnosticHolder) 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 c4b7dee85f4..151ab83df96 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 @@ -112,7 +112,7 @@ object ImplementationConfigurator : AbstractFirTreeImplementationConfigurator() } } - impl(arrayOfCall) + impl(arrayLiteral) impl(callableReferenceAccess) @@ -666,7 +666,7 @@ object ImplementationConfigurator : AbstractFirTreeImplementationConfigurator() "FirVarargArgumentsExpressionImpl", "FirSafeCallExpressionImpl", "FirCheckedSafeCallSubjectImpl", - "FirArrayOfCallImpl", + "FirArrayLiteralImpl", "FirIntegerLiteralOperatorCallImpl", "FirContextReceiverImpl", "FirReceiverParameterImpl", diff --git a/compiler/visualizer/render-fir/src/org/jetbrains/kotlin/compiler/visualizer/FirVisualizer.kt b/compiler/visualizer/render-fir/src/org/jetbrains/kotlin/compiler/visualizer/FirVisualizer.kt index 22940c74e9a..01fd145da12 100644 --- a/compiler/visualizer/render-fir/src/org/jetbrains/kotlin/compiler/visualizer/FirVisualizer.kt +++ b/compiler/visualizer/render-fir/src/org/jetbrains/kotlin/compiler/visualizer/FirVisualizer.kt @@ -265,7 +265,7 @@ class FirVisualizer(private val firFile: FirFile) : BaseRenderer() { override fun visitCallExpression(expression: KtCallExpression) { expression.firstOfTypeWithLocalReplace { this.calleeReference.name.asString() } - ?: expression.firstOfTypeWithRender() + ?: expression.firstOfTypeWithRender() expression.children.filter { it.node.elementType != KtNodeTypes.REFERENCE_EXPRESSION }.forEach { psi -> when (psi) { is KtLambdaArgument -> { @@ -844,9 +844,9 @@ class FirVisualizer(private val firFile: FirFile) : BaseRenderer() { getClassCall.argument.accept(this, data) } - override fun visitArrayOfCall(arrayOfCall: FirArrayOfCall, data: StringBuilder) { - val name = arrayOfCall.typeRef.coneType.classId!!.shortClassName.asString() - val typeArguments = arrayOfCall.typeRef.coneType.typeArguments + override fun visitArrayLiteral(arrayLiteral: FirArrayLiteral, data: StringBuilder) { + val name = arrayLiteral.typeRef.coneType.classId!!.shortClassName.asString() + val typeArguments = arrayLiteral.typeRef.coneType.typeArguments val typeParameters = if (typeArguments.isEmpty()) "" else " " data.append("fun$typeParameters ${name.replaceFirstChar(Char::lowercaseChar)}Of") typeArguments.firstOrNull()?.let { diff --git a/plugins/kotlinx-serialization/kotlinx-serialization.k2/src/org/jetbrains/kotlinx/serialization/compiler/fir/checkers/FirSerializationPluginClassChecker.kt b/plugins/kotlinx-serialization/kotlinx-serialization.k2/src/org/jetbrains/kotlinx/serialization/compiler/fir/checkers/FirSerializationPluginClassChecker.kt index 6065b42b37e..349ba87bed2 100644 --- a/plugins/kotlinx-serialization/kotlinx-serialization.k2/src/org/jetbrains/kotlinx/serialization/compiler/fir/checkers/FirSerializationPluginClassChecker.kt +++ b/plugins/kotlinx-serialization/kotlinx-serialization.k2/src/org/jetbrains/kotlinx/serialization/compiler/fir/checkers/FirSerializationPluginClassChecker.kt @@ -185,12 +185,12 @@ object FirSerializationPluginClassChecker : FirClassChecker() { else -> { val argumentsIfArray1 = when (this) { is FirVarargArgumentsExpression -> arguments - is FirArrayOfCall -> arguments + is FirArrayLiteral -> arguments else -> return false } val argumentsIfArray2 = when (other) { is FirVarargArgumentsExpression -> other.arguments - is FirArrayOfCall -> other.arguments + is FirArrayLiteral -> other.arguments else -> return false } argumentsIfArray1.size == argumentsIfArray2.size && argumentsIfArray1.zip(argumentsIfArray2) diff --git a/plugins/kotlinx-serialization/kotlinx-serialization.k2/src/org/jetbrains/kotlinx/serialization/compiler/fir/services/ContextualSerializersProvider.kt b/plugins/kotlinx-serialization/kotlinx-serialization.k2/src/org/jetbrains/kotlinx/serialization/compiler/fir/services/ContextualSerializersProvider.kt index 63473975630..10f6950688f 100644 --- a/plugins/kotlinx-serialization/kotlinx-serialization.k2/src/org/jetbrains/kotlinx/serialization/compiler/fir/services/ContextualSerializersProvider.kt +++ b/plugins/kotlinx-serialization/kotlinx-serialization.k2/src/org/jetbrains/kotlinx/serialization/compiler/fir/services/ContextualSerializersProvider.kt @@ -67,7 +67,7 @@ class ContextualSerializersProvider(session: FirSession) : FirExtensionSessionCo annotationClassId, session ) ?: return emptyList() val arguments = when (val argument = annotation.argumentMapping.mapping.values.firstOrNull()) { - is FirArrayOfCall -> argument.arguments + is FirArrayLiteral -> argument.arguments is FirVarargArgumentsExpression -> argument.arguments else -> return emptyList() }