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

K2. Minor. Rename FirConstExpression to FirLiteralExpression

Browse Source 
FirConstExpression is usually confused with "constant" calculations,
while in fact, it just denotes a simple literal expression
and `1 + 1` isn't represented by a FirConstExpression.

^KT-64314 Fixed
This commit is contained in:
Simon Ogorodnik
2024-01-12 18:44:13 +01:00
committed by Space Team
parent 213967e25c
commit 53e89a9722
105 changed files with 300 additions and 295 deletions
Download Patch File Download Diff File Expand all files Collapse all files
analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/evaluate/FirAnnotationValueConverter.kt
+2 -2
View File
@@ -42,7 +42,7 @@ internal object FirAnnotationValueConverter {
)
}
private fun <T> FirConstExpression<T>.convertConstantExpression(): KtConstantAnnotationValue? {
private fun <T> FirLiteralExpression<T>.convertConstantExpression(): KtConstantAnnotationValue? {
val expression = psi as? KtElement
@OptIn(UnresolvedExpressionTypeAccess::class)
@@ -98,7 +98,7 @@ internal object FirAnnotationValueConverter {
private fun FirExpression.convertConstantExpression(builder: KtSymbolByFirBuilder): KtAnnotationValue? {
val sourcePsi = psi as? KtElement
return when (this) {
is FirConstExpression<*> -> convertConstantExpression()
is FirLiteralExpression<*> -> convertConstantExpression()
is FirNamedArgumentExpression -> {
expression.convertConstantExpression(builder)
}
analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/evaluate/FirCompileTimeConstantEvaluator.kt
+29 -29
View File
@@ -17,7 +17,7 @@ import org.jetbrains.kotlin.fir.declarations.utils.isConst
import org.jetbrains.kotlin.fir.declarations.utils.isFinal
import org.jetbrains.kotlin.fir.declarations.utils.isStatic
import org.jetbrains.kotlin.fir.expressions.*
import org.jetbrains.kotlin.fir.expressions.builder.buildConstExpression
import org.jetbrains.kotlin.fir.expressions.builder.buildLiteralExpression
import org.jetbrains.kotlin.fir.psi
import org.jetbrains.kotlin.fir.references.FirNamedReference
import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
@@ -45,7 +45,7 @@ internal object FirCompileTimeConstantEvaluator {
fun evaluate(
fir: FirElement?,
mode: KtConstantEvaluationMode,
): FirConstExpression<*>? =
): FirLiteralExpression<*>? =
when (fir) {
is FirPropertyAccessExpression -> {
when (val referredVariable = fir.calleeReference.toResolvedVariableSymbol()) {
@@ -53,14 +53,14 @@ internal object FirCompileTimeConstantEvaluator {
if (referredVariable.callableId.isStringLength) {
evaluate(fir.explicitReceiver, mode)?.evaluateStringLength()
} else {
referredVariable.toConstExpression(mode)
referredVariable.toLiteralExpression(mode)
}
}
is FirFieldSymbol -> referredVariable.toConstExpression(mode)
is FirFieldSymbol -> referredVariable.toLiteralExpression(mode)
else -> null
}
}
is FirConstExpression<*> -> {
is FirLiteralExpression<*> -> {
fir.adaptToConstKind()
}
is FirFunctionCall -> {
@@ -70,7 +70,7 @@ internal object FirCompileTimeConstantEvaluator {
evaluateStringConcatenationCall(fir, mode)
}
is FirNamedReference -> {
fir.toResolvedPropertySymbol()?.toConstExpression(mode)
fir.toResolvedPropertySymbol()?.toLiteralExpression(mode)
}
else -> null
}
@@ -78,9 +78,9 @@ internal object FirCompileTimeConstantEvaluator {
private val CallableId.isStringLength: Boolean
get() = classId == StandardClassIds.String && callableName.identifierOrNullIfSpecial == "length"
private fun FirPropertySymbol.toConstExpression(
private fun FirPropertySymbol.toLiteralExpression(
mode: KtConstantEvaluationMode,
): FirConstExpression<*>? {
): FirLiteralExpression<*>? {
return when {
mode == KtConstantEvaluationMode.CONSTANT_EXPRESSION_EVALUATION && !isConst -> null
isVal && hasInitializer -> {
@@ -92,9 +92,9 @@ internal object FirCompileTimeConstantEvaluator {
}
}
private fun FirFieldSymbol.toConstExpression(
private fun FirFieldSymbol.toLiteralExpression(
mode: KtConstantEvaluationMode,
): FirConstExpression<*>? {
): FirLiteralExpression<*>? {
return when {
mode == KtConstantEvaluationMode.CONSTANT_EXPRESSION_EVALUATION && !(isStatic && isFinal) -> null
isVal && hasInitializer -> {
@@ -148,8 +148,8 @@ internal object FirCompileTimeConstantEvaluator {
}
}
private fun FirConstExpression<*>.adaptToConstKind(): FirConstExpression<*> {
return kind.toConstExpression(
private fun FirLiteralExpression<*>.adaptToConstKind(): FirLiteralExpression<*> {
return kind.toLiteralExpression(
source,
kind.convertToNumber(value as? Number) ?: value
)
@@ -158,7 +158,7 @@ internal object FirCompileTimeConstantEvaluator {
private fun evaluateStringConcatenationCall(
stringConcatenationCall: FirStringConcatenationCall,
mode: KtConstantEvaluationMode,
): FirConstExpression<String>? {
): FirLiteralExpression<String>? {
val concatenated = buildString {
for (arg in stringConcatenationCall.arguments) {
val evaluated = evaluate(arg, mode) ?: return null
@@ -166,13 +166,13 @@ internal object FirCompileTimeConstantEvaluator {
}
}
return ConstantValueKind.String.toConstExpression(stringConcatenationCall.source, concatenated)
return ConstantValueKind.String.toLiteralExpression(stringConcatenationCall.source, concatenated)
}
private fun evaluateFunctionCall(
functionCall: FirFunctionCall,
mode: KtConstantEvaluationMode,
): FirConstExpression<*>? {
): FirLiteralExpression<*>? {
val function = functionCall.getOriginalFunction() as? FirSimpleFunction ?: return null
val opr1 = evaluate(functionCall.explicitReceiver, mode) ?: return null
@@ -188,7 +188,7 @@ internal object FirCompileTimeConstantEvaluator {
return null
}
private fun FirConstExpression<*>.adjustType(expectedType: ConeKotlinType): FirConstExpression<*> {
private fun FirLiteralExpression<*>.adjustType(expectedType: ConeKotlinType): FirLiteralExpression<*> {
val expectedKind = expectedType.toConstantValueKind()
// Note that the resolved type for the const expression is not always matched with the const kind. For example,
// fun foo(x: Int) {
@@ -200,7 +200,7 @@ internal object FirCompileTimeConstantEvaluator {
val expression =
if (expectedKind != null && expectedKind != kind && value is Number) {
val typeAdjustedValue = expectedKind.convertToNumber(value as Number)!!
expectedKind.toConstExpression(source, typeAdjustedValue)
expectedKind.toLiteralExpression(source, typeAdjustedValue)
} else {
this
}
@@ -227,7 +227,7 @@ internal object FirCompileTimeConstantEvaluator {
}
// Unary operators
private fun FirConstExpression<*>.evaluate(function: FirSimpleFunction): FirConstExpression<*>? {
private fun FirLiteralExpression<*>.evaluate(function: FirSimpleFunction): FirLiteralExpression<*>? {
if (value == null) return null
(value as? String)?.let { opr ->
evalUnaryOp(
@@ -235,7 +235,7 @@ internal object FirCompileTimeConstantEvaluator {
kind.toCompileTimeType(),
opr
)?.let {
return it.toConstantValueKind().toConstExpression(source, it)
return it.toConstantValueKind().toLiteralExpression(source, it)
}
}
return kind.convertToNumber(value as? Number)?.let { opr ->
@@ -244,22 +244,22 @@ internal object FirCompileTimeConstantEvaluator {
kind.toCompileTimeType(),
opr
)?.let {
it.toConstantValueKind().toConstExpression(source, it)
it.toConstantValueKind().toLiteralExpression(source, it)
}
}
}
private fun FirConstExpression<*>.evaluateStringLength(): FirConstExpression<*>? {
private fun FirLiteralExpression<*>.evaluateStringLength(): FirLiteralExpression<*>? {
return (value as? String)?.length?.let {
it.toConstantValueKind().toConstExpression(source, it)
it.toConstantValueKind().toLiteralExpression(source, it)
}
}
// Binary operators
private fun FirConstExpression<*>.evaluate(
private fun FirLiteralExpression<*>.evaluate(
function: FirSimpleFunction,
other: FirConstExpression<*>
): FirConstExpression<*>? {
other: FirLiteralExpression<*>
): FirLiteralExpression<*>? {
if (value == null || other.value == null) return null
// NB: some utils accept very general types, and due to the way operation map works, we should up-cast rhs type.
val rightType = when {
@@ -276,7 +276,7 @@ internal object FirCompileTimeConstantEvaluator {
rightType,
opr2
)?.let {
return it.toConstantValueKind().toConstExpression(source, it)
return it.toConstantValueKind().toLiteralExpression(source, it)
}
}
}
@@ -289,7 +289,7 @@ internal object FirCompileTimeConstantEvaluator {
other.kind.toCompileTimeType(),
opr2
)?.let {
it.toConstantValueKind().toConstExpression(source, it)
it.toConstantValueKind().toLiteralExpression(source, it)
}
}
}
@@ -367,9 +367,9 @@ internal object FirCompileTimeConstantEvaluator {
}
}
private fun <T> ConstantValueKind<T>.toConstExpression(source: KtSourceElement?, value: Any?): FirConstExpression<T> =
private fun <T> ConstantValueKind<T>.toLiteralExpression(source: KtSourceElement?, value: Any?): FirLiteralExpression<T> =
@Suppress("UNCHECKED_CAST")
buildConstExpression(source, this, value as T, setType = false)
buildLiteralExpression(source, this, value as T, setType = false)
private fun FirFunctionCall.getOriginalFunction(): FirCallableDeclaration? {
val symbol: FirBasedSymbol<*>? = when (val reference = calleeReference) {
analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/file/structure/FirElementsRecorder.kt
+13 -13
View File
@@ -12,7 +12,7 @@ import org.jetbrains.kotlin.fir.FirElement
import org.jetbrains.kotlin.fir.builder.toFirOperationOrNull
import org.jetbrains.kotlin.fir.declarations.FirTypeParameter
import org.jetbrains.kotlin.fir.expressions.*
import org.jetbrains.kotlin.fir.expressions.builder.buildConstExpression
import org.jetbrains.kotlin.fir.expressions.builder.buildLiteralExpression
import org.jetbrains.kotlin.fir.psi
import org.jetbrains.kotlin.fir.references.*
import org.jetbrains.kotlin.fir.types.*
@@ -77,16 +77,16 @@ internal open class FirElementsRecorder : FirVisitor<Unit, MutableMap<KtElement,
visitElement(variableAssignment, data)
}
override fun <T> visitConstExpression(constExpression: FirConstExpression<T>, data: MutableMap<KtElement, FirElement>) {
cacheElement(constExpression, data)
constExpression.annotations.forEach {
override fun <T> visitLiteralExpression(literalExpression: FirLiteralExpression<T>, data: MutableMap<KtElement, FirElement>) {
cacheElement(literalExpression, data)
literalExpression.annotations.forEach {
it.accept(this, data)
}
// KtPrefixExpression(-, KtConstExpression(n)) is represented as FirConstExpression(-n) with converted constant value.
// If one queries FIR for KtConstExpression, we still return FirConstExpression(-n) even though its source is KtPrefixExpression.
// Here, we cache FirConstExpression(n) for KtConstExpression(n) to make everything natural and intuitive!
if (constExpression.isConverted) {
constExpression.kind.reverseConverted(constExpression)?.let { cacheElement(it, data) }
// KtPrefixExpression(-, KtConstExpression(n)) is represented as FirLiteralExpression(-n) with converted constant value.
// If one queries FIR for KtConstExpression, we still return FirLiteralExpression(-n) even though its source is KtPrefixExpression.
// Here, we cache FirLiteralExpression(n) for KtConstExpression(n) to make everything natural and intuitive!
if (literalExpression.isConverted) {
literalExpression.kind.reverseConverted(literalExpression)?.let { cacheElement(it, data) }
}
}
@@ -192,19 +192,19 @@ internal open class FirElementsRecorder : FirVisitor<Unit, MutableMap<KtElement,
return FirOperationNameConventions.ASSIGNMENTS[firOperation]
}
private val FirConstExpression<*>.isConverted: Boolean
private val FirLiteralExpression<*>.isConverted: Boolean
get() {
val firSourcePsi = this.source?.psi ?: return false
return firSourcePsi is KtPrefixExpression && firSourcePsi.operationToken == KtTokens.MINUS
}
private val FirConstExpression<*>.ktConstantExpression: KtConstantExpression?
private val FirLiteralExpression<*>.ktConstantExpression: KtConstantExpression?
get() {
val firSourcePsi = this.source?.psi
return firSourcePsi?.findDescendantOfType()
}
private fun <T> ConstantValueKind<T>.reverseConverted(original: FirConstExpression<T>): FirConstExpression<T>? {
private fun <T> ConstantValueKind<T>.reverseConverted(original: FirLiteralExpression<T>): FirLiteralExpression<T>? {
val value = original.value as? Number ?: return null
val convertedValue = when (this) {
ConstantValueKind.Byte -> value.toByte().unaryMinus()
@@ -216,7 +216,7 @@ internal open class FirElementsRecorder : FirVisitor<Unit, MutableMap<KtElement,
else -> null
} ?: return null
@Suppress("UNCHECKED_CAST")
return buildConstExpression(
return buildLiteralExpression(
original.ktConstantExpression?.toKtPsiSourceElement(),
this,
convertedValue as T,
analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/lazy/resolve/FirLazyBodiesCalculator.kt
+1 -1
View File
@@ -320,7 +320,7 @@ private fun rebindThisRef(
oldTarget: FirPropertySymbol,
canHavePropertySymbolAsThisReference: Boolean,
) {
if (expression is FirConstExpression<*>) return
if (expression is FirLiteralExpression<*>) return
requireWithAttachment(
expression is FirThisReceiverExpression,
analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/stubBased/deserialization/StubBasedAnnotationDeserializer.kt
+3 -3
View File
@@ -13,7 +13,7 @@ import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.declarations.FirRegularClass
import org.jetbrains.kotlin.fir.declarations.collectEnumEntries
import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.expressions.FirConstExpression
import org.jetbrains.kotlin.fir.expressions.FirLiteralExpression
import org.jetbrains.kotlin.fir.expressions.FirExpression
import org.jetbrains.kotlin.fir.expressions.buildUnaryArgumentList
import org.jetbrains.kotlin.fir.expressions.builder.*
@@ -198,8 +198,8 @@ class StubBasedAnnotationDeserializer(
value: T,
typeRef: FirResolvedTypeRef,
sourceElement: PsiElement
): FirConstExpression<T> {
return buildConstExpression(
): FirLiteralExpression<T> {
return buildLiteralExpression(
KtRealPsiSourceElement(sourceElement),
kind,
value,
analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/stubBased/deserialization/StubBasedFirTypeDeserializer.kt
+2 -2
View File
@@ -18,7 +18,7 @@ import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnostic
import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind
import org.jetbrains.kotlin.fir.expressions.builder.buildAnnotation
import org.jetbrains.kotlin.fir.expressions.builder.buildAnnotationArgumentMapping
import org.jetbrains.kotlin.fir.expressions.builder.buildConstExpression
import org.jetbrains.kotlin.fir.expressions.builder.buildLiteralExpression
import org.jetbrains.kotlin.fir.symbols.*
import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol
@@ -121,7 +121,7 @@ internal class StubBasedFirTypeDeserializer(
}
this.argumentMapping = buildAnnotationArgumentMapping {
mapping[StandardNames.NAME] =
buildConstExpression(null, ConstantValueKind.String, paramName, setType = true)
buildLiteralExpression(null, ConstantValueKind.String, paramName, setType = true)
}
}
}
analysis/low-level-api-fir/testData/getOrBuildFir/annotations/annotationApplicationArgument.txt
Vendored
+1 -1
View File
@@ -1,5 +1,5 @@
KT element: KtValueArgument
FIR element: FirConstExpressionImpl
FIR element: FirLiteralExpressionImpl
FIR source kind: KtRealSourceElementKind
FIR element rendered:
analysis/low-level-api-fir/testData/getOrBuildFir/annotations/annotationApplicationArgumentOnStatement.txt
Vendored
+1 -1
View File
@@ -1,5 +1,5 @@
KT element: KtValueArgument
FIR element: FirConstExpressionImpl
FIR element: FirLiteralExpressionImpl
FIR source kind: KtRealSourceElementKind
FIR element rendered:
analysis/low-level-api-fir/testData/getOrBuildFir/annotations/annotationApplicationArgumentScript.txt
Vendored
+1 -1
View File
@@ -1,5 +1,5 @@
KT element: KtValueArgument
FIR element: FirConstExpressionImpl
FIR element: FirLiteralExpressionImpl
FIR source kind: KtRealSourceElementKind
FIR element rendered:
analysis/low-level-api-fir/testData/getOrBuildFir/annotations/annotationApplicationVarargArgument.txt
Vendored
+1 -1
View File
@@ -1,5 +1,5 @@
KT element: KtValueArgument
FIR element: FirConstExpressionImpl
FIR element: FirLiteralExpressionImpl
FIR source kind: KtRealSourceElementKind
FIR element rendered:
analysis/low-level-api-fir/testData/getOrBuildFir/annotations/typeOnAnnotationOnConstructorParameterExpression.txt
Vendored
+1 -1
View File
@@ -1,5 +1,5 @@
KT element: KtStringTemplateExpression
FIR element: FirConstExpressionImpl
FIR element: FirLiteralExpressionImpl
FIR source kind: KtRealSourceElementKind
FIR element rendered:
analysis/low-level-api-fir/testData/getOrBuildFir/annotations/typeOnAnnotationOnConstructorParameterExpressionScript.txt
Vendored
+1 -1
View File
@@ -1,5 +1,5 @@
KT element: KtStringTemplateExpression
FIR element: FirConstExpressionImpl
FIR element: FirLiteralExpressionImpl
FIR source kind: KtRealSourceElementKind
FIR element rendered:
analysis/low-level-api-fir/testData/getOrBuildFir/calls/callArgument.txt
Vendored
+1 -1
View File
@@ -1,5 +1,5 @@
KT element: KtValueArgument
FIR element: FirConstExpressionImpl
FIR element: FirLiteralExpressionImpl
FIR source kind: KtRealSourceElementKind
FIR element rendered:
analysis/low-level-api-fir/testData/getOrBuildFir/calls/callArgumentScript.txt
Vendored
+1 -1
View File
@@ -1,5 +1,5 @@
KT element: KtValueArgument
FIR element: FirConstExpressionImpl
FIR element: FirLiteralExpressionImpl
FIR source kind: KtRealSourceElementKind
FIR element rendered:
analysis/low-level-api-fir/testData/getOrBuildFir/expressions/arrayIndexExpressionWithInc.out_of_src_roots.txt
Vendored
+1 -1
View File
@@ -1,5 +1,5 @@
KT element: KtConstantExpression
FIR element: FirConstExpressionImpl
FIR element: FirLiteralExpressionImpl
FIR source kind: KtRealSourceElementKind
FIR element rendered:
analysis/low-level-api-fir/testData/getOrBuildFir/expressions/arrayIndexExpressionWithInc.txt
Vendored
+1 -1
View File
@@ -1,5 +1,5 @@
KT element: KtConstantExpression
FIR element: FirConstExpressionImpl
FIR element: FirLiteralExpressionImpl
FIR source kind: KtRealSourceElementKind
FIR element rendered:
analysis/low-level-api-fir/testData/getOrBuildFir/expressions/arrayIndexExpressionWithIncScript.txt
Vendored
+1 -1
View File
@@ -1,5 +1,5 @@
KT element: KtConstantExpression
FIR element: FirConstExpressionImpl
FIR element: FirLiteralExpressionImpl
FIR source kind: KtRealSourceElementKind
FIR element rendered:
analysis/low-level-api-fir/testData/getOrBuildFir/expressions/assignment.txt
Vendored
+1 -1
View File
@@ -1,5 +1,5 @@
KT element: KtStringTemplateExpression
FIR element: FirConstExpressionImpl
FIR element: FirLiteralExpressionImpl
FIR source kind: KtRealSourceElementKind
FIR element rendered:
analysis/low-level-api-fir/testData/getOrBuildFir/expressions/boolLiteral.txt
Vendored
+1 -1
View File
@@ -1,5 +1,5 @@
KT element: KtConstantExpression
FIR element: FirConstExpressionImpl
FIR element: FirLiteralExpressionImpl
FIR source kind: KtRealSourceElementKind
FIR element rendered:
analysis/low-level-api-fir/testData/getOrBuildFir/expressions/boolLiteralScript.txt
Vendored
+1 -1
View File
@@ -1,5 +1,5 @@
KT element: KtConstantExpression
FIR element: FirConstExpressionImpl
FIR element: FirLiteralExpressionImpl
FIR source kind: KtRealSourceElementKind
FIR element rendered:
analysis/low-level-api-fir/testData/getOrBuildFir/expressions/intLiteral.txt
Vendored
+1 -1
View File
@@ -1,5 +1,5 @@
KT element: KtConstantExpression
FIR element: FirConstExpressionImpl
FIR element: FirLiteralExpressionImpl
FIR source kind: KtRealSourceElementKind
FIR element rendered:
analysis/low-level-api-fir/testData/getOrBuildFir/expressions/intLiteralScript.txt
Vendored
+1 -1
View File
@@ -1,5 +1,5 @@
KT element: KtConstantExpression
FIR element: FirConstExpressionImpl
FIR element: FirLiteralExpressionImpl
FIR source kind: KtRealSourceElementKind
FIR element rendered:
analysis/low-level-api-fir/testData/getOrBuildFir/expressions/intLiteral_minusOne_entire.txt
Vendored
+1 -1
View File
@@ -1,5 +1,5 @@
KT element: KtPrefixExpression
FIR element: FirConstExpressionImpl
FIR element: FirLiteralExpressionImpl
FIR source kind: KtRealSourceElementKind
FIR element rendered:
analysis/low-level-api-fir/testData/getOrBuildFir/expressions/intLiteral_minusOne_justOne.txt
Vendored
+1 -1
View File
@@ -1,5 +1,5 @@
KT element: KtConstantExpression
FIR element: FirConstExpressionImpl
FIR element: FirLiteralExpressionImpl
FIR source kind: KtRealSourceElementKind
FIR element rendered:
analysis/low-level-api-fir/testData/getOrBuildFir/expressions/intLiteral_plusOne_entire.txt
Vendored
+1 -1
View File
@@ -1,5 +1,5 @@
KT element: KtPrefixExpression
FIR element: FirConstExpressionImpl
FIR element: FirLiteralExpressionImpl
FIR source kind: KtRealSourceElementKind
FIR element rendered:
analysis/low-level-api-fir/testData/getOrBuildFir/expressions/intLiteral_plusOne_justOne.txt
Vendored
+1 -1
View File
@@ -1,5 +1,5 @@
KT element: KtConstantExpression
FIR element: FirConstExpressionImpl
FIR element: FirLiteralExpressionImpl
FIR source kind: KtRealSourceElementKind
FIR element rendered:
analysis/low-level-api-fir/testData/getOrBuildFir/expressions/stringLiteral.txt
Vendored
+1 -1
View File
@@ -1,5 +1,5 @@
KT element: KtStringTemplateExpression
FIR element: FirConstExpressionImpl
FIR element: FirLiteralExpressionImpl
FIR source kind: KtRealSourceElementKind
FIR element rendered:
analysis/low-level-api-fir/testData/getOrBuildFir/expressions/stringLiteralScript.txt
Vendored
+1 -1
View File
@@ -1,5 +1,5 @@
KT element: KtStringTemplateExpression
FIR element: FirConstExpressionImpl
FIR element: FirLiteralExpressionImpl
FIR source kind: KtRealSourceElementKind
FIR element rendered:
compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/Main.kt
+1 -1
View File
@@ -56,7 +56,7 @@ fun main(args: Array<String>) {
alias<FirStringConcatenationCall>("StringConcatenationCallChecker")
alias<FirTypeOperatorCall>("TypeOperatorCallChecker")
alias<FirResolvedQualifier>("ResolvedQualifierChecker")
alias<FirConstExpression<*>>("ConstExpressionChecker")
alias<FirLiteralExpression<*>>("LiteralExpressionChecker")
alias<FirCallableReferenceAccess>("CallableReferenceAccessChecker")
alias<FirThisReceiverExpression>("ThisReceiverExpressionChecker")
alias<FirWhileLoop>("WhileLoopChecker")
compiler/fir/checkers/checkers.js/src/org/jetbrains/kotlin/fir/analysis/js/checkers/declaration/FirJsExportDeclarationChecker.kt
+2 -2
View File
@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.fir.analysis.js.checkers.isExportedObject
import org.jetbrains.kotlin.fir.analysis.js.checkers.sanitizeName
import org.jetbrains.kotlin.fir.declarations.*
import org.jetbrains.kotlin.fir.declarations.utils.*
import org.jetbrains.kotlin.fir.expressions.FirConstExpression
import org.jetbrains.kotlin.fir.expressions.FirLiteralExpression
import org.jetbrains.kotlin.fir.isEnumEntries
import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
@@ -242,7 +242,7 @@ object FirJsExportDeclarationChecker : FirBasicDeclarationChecker(MppCheckerKind
val jsNameArgument = declaration.symbol.getAnnotationFirstArgument(JsStandardClassIds.Annotations.JsName, context.session)
val reportTarget = jsNameArgument?.source ?: declaration.source
val name = (jsNameArgument as? FirConstExpression<*>)?.value as? String ?: declaration.nameOrSpecialName.asString()
val name = (jsNameArgument as? FirLiteralExpression<*>)?.value as? String ?: declaration.nameOrSpecialName.asString()
if (name in SPECIAL_KEYWORDS || (name !in RESERVED_KEYWORDS && sanitizeName(name) == name)) {
return
compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirJvmNameChecker.kt
+2 -2
View File
@@ -17,7 +17,7 @@ import org.jetbrains.kotlin.fir.declarations.*
import org.jetbrains.kotlin.fir.declarations.utils.isInline
import org.jetbrains.kotlin.fir.declarations.utils.isOverridable
import org.jetbrains.kotlin.fir.declarations.utils.isOverride
import org.jetbrains.kotlin.fir.expressions.FirConstExpression
import org.jetbrains.kotlin.fir.expressions.FirLiteralExpression
import org.jetbrains.kotlin.fir.java.findJvmNameAnnotation
import org.jetbrains.kotlin.fir.resolve.getContainingClass
import org.jetbrains.kotlin.fir.types.resolvedType
@@ -34,7 +34,7 @@ object FirJvmNameChecker : FirBasicDeclarationChecker(MppCheckerKind.Common) {
return
}
val value = (name as? FirConstExpression<*>)?.value as? String ?: return
val value = (name as? FirLiteralExpression<*>)?.value as? String ?: return
if (!Name.isValidIdentifier(value)) {
reporter.reportOn(jvmName.source, FirJvmErrors.ILLEGAL_JVM_NAME, context)
compiler/fir/checkers/checkers.native/src/org/jetbrains/kotlin/fir/analysis/native/checkers/FirNativeObjCNameChecker.kt
+8 -2
View File
@@ -26,7 +26,13 @@ import org.jetbrains.kotlin.fir.declarations.FirClass
import org.jetbrains.kotlin.fir.declarations.FirDeclaration
import org.jetbrains.kotlin.fir.declarations.FirValueParameter
import org.jetbrains.kotlin.fir.declarations.utils.isOverride
import org.jetbrains.kotlin.fir.expressions.FirConstExpression
import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.expressions.FirLiteralExpression
import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
import org.jetbrains.kotlin.name.ClassId
import org.jetbrains.kotlin.name.FqName
import org.jetbrains.kotlin.name.Name
object FirNativeObjCNameChecker : FirBasicDeclarationChecker(MppCheckerKind.Common) {
override fun check(declaration: FirDeclaration, context: CheckerContext, reporter: DiagnosticReporter) {
@@ -48,7 +54,7 @@ object FirNativeObjCNameChecker : FirBasicDeclarationChecker(MppCheckerKind.Comm
private fun checkObjCName(objCName: ObjCName, declaration: FirDeclaration, context: CheckerContext, reporter: DiagnosticReporter) {
val annotationSource = objCName.annotation.source
for ((_, argument) in objCName.annotation.argumentMapping.mapping) {
if (argument is FirConstExpression<*>) continue
if (argument is FirLiteralExpression<*>) continue
reporter.reportOn(argument.source, NON_LITERAL_OBJC_NAME_ARG, context)
}
if (objCName.name == null && objCName.swiftName == null) {
compiler/fir/checkers/checkers.web.common/src/org/jetbrains/kotlin/fir/analysis/web/common/checkers/expression/FirJsQualifierChecker.kt
+2 -2
View File
@@ -13,7 +13,7 @@ import org.jetbrains.kotlin.fir.analysis.checkers.expression.FirAnnotationCallCh
import org.jetbrains.kotlin.fir.analysis.diagnostics.web.common.FirWebCommonErrors
import org.jetbrains.kotlin.fir.declarations.toAnnotationClassId
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
import org.jetbrains.kotlin.fir.expressions.FirConstExpression
import org.jetbrains.kotlin.fir.expressions.FirLiteralExpression
import org.jetbrains.kotlin.js.validateQualifier
import org.jetbrains.kotlin.name.WebCommonStandardClassIds.Annotations.JsQualifier
@@ -23,7 +23,7 @@ object FirJsQualifierChecker : FirAnnotationCallChecker(MppCheckerKind.Common) {
return
}
val string = (expression.argumentMapping.mapping.values.firstOrNull() as? FirConstExpression<*>)?.value as? String ?: return
val string = (expression.argumentMapping.mapping.values.firstOrNull() as? FirLiteralExpression<*>)?.value as? String ?: return
if (!validateQualifier(string)) {
reporter.reportOn(expression.argumentList.arguments.first().source, FirWebCommonErrors.WRONG_JS_QUALIFIER, context)
compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/checkers/expression/ComposedExpressionCheckers.kt
+4 -4
View File
@@ -65,8 +65,8 @@ class ComposedExpressionCheckers(val predicate: (FirCheckerWithMppKind) -> Boole
get() = _typeOperatorCallCheckers
override val resolvedQualifierCheckers: Set<FirResolvedQualifierChecker>
get() = _resolvedQualifierCheckers
override val constExpressionCheckers: Set<FirConstExpressionChecker>
get() = _constExpressionCheckers
override val literalExpressionCheckers: Set<FirLiteralExpressionChecker>
get() = _literalExpressionCheckers
override val callableReferenceAccessCheckers: Set<FirCallableReferenceAccessChecker>
get() = _callableReferenceAccessCheckers
override val thisReceiverExpressionCheckers: Set<FirThisReceiverExpressionChecker>
@@ -108,7 +108,7 @@ class ComposedExpressionCheckers(val predicate: (FirCheckerWithMppKind) -> Boole
private val _stringConcatenationCallCheckers: MutableSet<FirStringConcatenationCallChecker> = mutableSetOf()
private val _typeOperatorCallCheckers: MutableSet<FirTypeOperatorCallChecker> = mutableSetOf()
private val _resolvedQualifierCheckers: MutableSet<FirResolvedQualifierChecker> = mutableSetOf()
private val _constExpressionCheckers: MutableSet<FirConstExpressionChecker> = mutableSetOf()
private val _literalExpressionCheckers: MutableSet<FirLiteralExpressionChecker> = mutableSetOf()
private val _callableReferenceAccessCheckers: MutableSet<FirCallableReferenceAccessChecker> = mutableSetOf()
private val _thisReceiverExpressionCheckers: MutableSet<FirThisReceiverExpressionChecker> = mutableSetOf()
private val _whileLoopCheckers: MutableSet<FirWhileLoopChecker> = mutableSetOf()
@@ -144,7 +144,7 @@ class ComposedExpressionCheckers(val predicate: (FirCheckerWithMppKind) -> Boole
checkers.stringConcatenationCallCheckers.filterTo(_stringConcatenationCallCheckers, predicate)
checkers.typeOperatorCallCheckers.filterTo(_typeOperatorCallCheckers, predicate)
checkers.resolvedQualifierCheckers.filterTo(_resolvedQualifierCheckers, predicate)
checkers.constExpressionCheckers.filterTo(_constExpressionCheckers, predicate)
checkers.literalExpressionCheckers.filterTo(_literalExpressionCheckers, predicate)
checkers.callableReferenceAccessCheckers.filterTo(_callableReferenceAccessCheckers, predicate)
checkers.thisReceiverExpressionCheckers.filterTo(_thisReceiverExpressionCheckers, predicate)
checkers.whileLoopCheckers.filterTo(_whileLoopCheckers, predicate)
compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/checkers/expression/ExpressionCheckers.kt
+2 -2
View File
@@ -41,7 +41,7 @@ abstract class ExpressionCheckers {
open val stringConcatenationCallCheckers: Set<FirStringConcatenationCallChecker> = emptySet()
open val typeOperatorCallCheckers: Set<FirTypeOperatorCallChecker> = emptySet()
open val resolvedQualifierCheckers: Set<FirResolvedQualifierChecker> = emptySet()
open val constExpressionCheckers: Set<FirConstExpressionChecker> = emptySet()
open val literalExpressionCheckers: Set<FirLiteralExpressionChecker> = emptySet()
open val callableReferenceAccessCheckers: Set<FirCallableReferenceAccessChecker> = emptySet()
open val thisReceiverExpressionCheckers: Set<FirThisReceiverExpressionChecker> = emptySet()
open val whileLoopCheckers: Set<FirWhileLoopChecker> = emptySet()
@@ -75,7 +75,7 @@ abstract class ExpressionCheckers {
@CheckersComponentInternal internal val allStringConcatenationCallCheckers: Set<FirStringConcatenationCallChecker> by lazy { stringConcatenationCallCheckers + basicExpressionCheckers + callCheckers }
@CheckersComponentInternal internal val allTypeOperatorCallCheckers: Set<FirTypeOperatorCallChecker> by lazy { typeOperatorCallCheckers + basicExpressionCheckers + callCheckers }
@CheckersComponentInternal internal val allResolvedQualifierCheckers: Set<FirResolvedQualifierChecker> by lazy { resolvedQualifierCheckers + basicExpressionCheckers }
@CheckersComponentInternal internal val allConstExpressionCheckers: Set<FirConstExpressionChecker> by lazy { constExpressionCheckers + basicExpressionCheckers }
@CheckersComponentInternal internal val allLiteralExpressionCheckers: Set<FirLiteralExpressionChecker> by lazy { literalExpressionCheckers + basicExpressionCheckers }
@CheckersComponentInternal internal val allCallableReferenceAccessCheckers: Set<FirCallableReferenceAccessChecker> by lazy { callableReferenceAccessCheckers + qualifiedAccessExpressionCheckers + basicExpressionCheckers }
@CheckersComponentInternal internal val allThisReceiverExpressionCheckers: Set<FirThisReceiverExpressionChecker> by lazy { thisReceiverExpressionCheckers + qualifiedAccessExpressionCheckers + basicExpressionCheckers }
@CheckersComponentInternal internal val allWhileLoopCheckers: Set<FirWhileLoopChecker> by lazy { whileLoopCheckers + loopExpressionCheckers + basicExpressionCheckers }
compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirExpressionCheckerAliases.kt
+2 -2
View File
@@ -19,7 +19,6 @@ import org.jetbrains.kotlin.fir.expressions.FirCall
import org.jetbrains.kotlin.fir.expressions.FirCallableReferenceAccess
import org.jetbrains.kotlin.fir.expressions.FirCheckNotNullCall
import org.jetbrains.kotlin.fir.expressions.FirClassReferenceExpression
import org.jetbrains.kotlin.fir.expressions.FirConstExpression
import org.jetbrains.kotlin.fir.expressions.FirDoWhileLoop
import org.jetbrains.kotlin.fir.expressions.FirElvisExpression
import org.jetbrains.kotlin.fir.expressions.FirEqualityOperatorCall
@@ -27,6 +26,7 @@ import org.jetbrains.kotlin.fir.expressions.FirFunctionCall
import org.jetbrains.kotlin.fir.expressions.FirGetClassCall
import org.jetbrains.kotlin.fir.expressions.FirInaccessibleReceiverExpression
import org.jetbrains.kotlin.fir.expressions.FirIntegerLiteralOperatorCall
import org.jetbrains.kotlin.fir.expressions.FirLiteralExpression
import org.jetbrains.kotlin.fir.expressions.FirLoop
import org.jetbrains.kotlin.fir.expressions.FirLoopJump
import org.jetbrains.kotlin.fir.expressions.FirPropertyAccessExpression
@@ -68,7 +68,7 @@ typealias FirEqualityOperatorCallChecker = FirExpressionChecker<FirEqualityOpera
typealias FirStringConcatenationCallChecker = FirExpressionChecker<FirStringConcatenationCall>
typealias FirTypeOperatorCallChecker = FirExpressionChecker<FirTypeOperatorCall>
typealias FirResolvedQualifierChecker = FirExpressionChecker<FirResolvedQualifier>
typealias FirConstExpressionChecker = FirExpressionChecker<FirConstExpression<*>>
typealias FirLiteralExpressionChecker = FirExpressionChecker<FirLiteralExpression<*>>
typealias FirCallableReferenceAccessChecker = FirExpressionChecker<FirCallableReferenceAccess>
typealias FirThisReceiverExpressionChecker = FirExpressionChecker<FirThisReceiverExpression>
typealias FirWhileLoopChecker = FirExpressionChecker<FirWhileLoop>
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/cfa/FirReturnsImpliesAnalyzer.kt
+2 -2
View File
@@ -19,7 +19,7 @@ import org.jetbrains.kotlin.fir.contracts.effects
import org.jetbrains.kotlin.fir.declarations.FirContractDescriptionOwner
import org.jetbrains.kotlin.fir.declarations.FirFunction
import org.jetbrains.kotlin.fir.declarations.FirProperty
import org.jetbrains.kotlin.fir.expressions.FirConstExpression
import org.jetbrains.kotlin.fir.expressions.FirLiteralExpression
import org.jetbrains.kotlin.fir.expressions.FirExpression
import org.jetbrains.kotlin.fir.expressions.FirReturnExpression
import org.jetbrains.kotlin.fir.expressions.FirWhenExpression
@@ -111,7 +111,7 @@ object FirReturnsImpliesAnalyzer : FirControlFlowChecker(MppCheckerKind.Common)
var flow = node.flow
val operation = effect.value.toOperation()
if (operation != null) {
if (resultExpression is FirConstExpression<*>) {
if (resultExpression is FirLiteralExpression<*>) {
if (!operation.isTrueFor(resultExpression.value)) return false
} else {
if (expressionType != null && !operation.canBeTrueFor(context.session, expressionType)) return false
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirConstChecks.kt
+3 -3
View File
@@ -119,7 +119,7 @@ private class FirConstCheckVisitor(private val session: FirSession) : FirVisitor
return if (intrinsicConstEvaluation) ConstantArgumentKind.VALID_CONST else ConstantArgumentKind.NOT_CONST
}
override fun <T> visitConstExpression(constExpression: FirConstExpression<T>, data: Nothing?): ConstantArgumentKind {
override fun <T> visitLiteralExpression(literalExpression: FirLiteralExpression<T>, data: Nothing?): ConstantArgumentKind {
return ConstantArgumentKind.VALID_CONST
}
@@ -143,7 +143,7 @@ private class FirConstCheckVisitor(private val session: FirSession) : FirVisitor
}
for (exp in equalityOperatorCall.arguments) {
if (exp is FirConstExpression<*> && exp.value == null) {
if (exp is FirLiteralExpression<*> && exp.value == null) {
return ConstantArgumentKind.NOT_CONST
}
@@ -219,7 +219,7 @@ private class FirConstCheckVisitor(private val session: FirSession) : FirVisitor
// Ok, because we only look at the structure, not resolution-dependent properties.
@OptIn(SymbolInternals::class)
return when (propertySymbol.fir.initializer) {
is FirConstExpression<*> -> when {
is FirLiteralExpression<*> -> when {
propertySymbol.isVal -> ConstantArgumentKind.NOT_CONST_VAL_IN_CONST_EXPRESSION
else -> ConstantArgumentKind.NOT_CONST
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirHelpers.kt
+1 -1
View File
@@ -792,7 +792,7 @@ fun FirBasedSymbol<*>.getAnnotationFirstArgument(classId: ClassId, session: FirS
}
fun FirBasedSymbol<*>.getAnnotationStringParameter(classId: ClassId, session: FirSession): String? {
val expression = getAnnotationFirstArgument(classId, session) as? FirConstExpression<*>
val expression = getAnnotationFirstArgument(classId, session) as? FirLiteralExpression<*>
return expression?.value as? String
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirSinceKotlinHelpers.kt
+2 -2
View File
@@ -9,7 +9,7 @@ import org.jetbrains.kotlin.config.ApiVersion
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
import org.jetbrains.kotlin.fir.declarations.*
import org.jetbrains.kotlin.fir.expressions.FirConstExpression
import org.jetbrains.kotlin.fir.expressions.FirLiteralExpression
import org.jetbrains.kotlin.fir.languageVersionSettings
import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
import org.jetbrains.kotlin.name.StandardClassIds
@@ -56,7 +56,7 @@ private fun FirDeclaration.getOwnSinceKotlinVersion(session: FirSession): FirSin
val sinceKotlinSingleArgument = getAnnotationByClassId(StandardClassIds.Annotations.SinceKotlin, session)?.findArgumentByName(
StandardClassIds.Annotations.ParameterNames.sinceKotlinVersion
)
val apiVersion = ((sinceKotlinSingleArgument as? FirConstExpression<*>)?.value as? String)?.let(ApiVersion.Companion::parse)
val apiVersion = ((sinceKotlinSingleArgument as? FirLiteralExpression<*>)?.value as? String)?.let(ApiVersion.Companion::parse)
return if (apiVersion != null) {
FirSinceKotlinValue(apiVersion, loadWasExperimentalMarkerClasses(session))
} else null
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirInlineDeclarationChecker.kt
+1 -1
View File
@@ -456,7 +456,7 @@ object FirInlineDeclarationChecker : FirFunctionChecker(MppCheckerKind.Common) {
expression is FirFunctionCall ||
expression is FirLambdaArgumentExpression ||
expression is FirAnonymousFunctionExpression ||
(expression is FirConstExpression<*> && expression.value == null) //this will be reported separately
(expression is FirLiteralExpression<*> && expression.value == null) //this will be reported separately
fun checkCallableDeclaration(declaration: FirCallableDeclaration, context: CheckerContext, reporter: DiagnosticReporter) {
if (declaration is FirPropertyAccessor) return
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirAnnotationExpressionChecker.kt
+3 -3
View File
@@ -123,8 +123,8 @@ object FirAnnotationExpressionChecker : FirAnnotationCallChecker(MppCheckerKind.
context: CheckerContext,
reporter: DiagnosticReporter
): ApiVersion? {
val constantExpression = (expression as? FirConstExpression<*>)
?: ((expression as? FirNamedArgumentExpression)?.expression as? FirConstExpression<*>) ?: return null
val constantExpression = (expression as? FirLiteralExpression<*>)
?: ((expression as? FirNamedArgumentExpression)?.expression as? FirLiteralExpression<*>) ?: return null
val stringValue = constantExpression.value as? String ?: return null
if (!stringValue.matches(RequireKotlinConstants.VERSION_REGEX)) {
reporter.reportOn(expression.source, FirErrors.ILLEGAL_KOTLIN_VERSION_STRING_VALUE, context)
@@ -242,7 +242,7 @@ object FirAnnotationExpressionChecker : FirAnnotationCallChecker(MppCheckerKind.
if (annotationClassId != StandardClassIds.Annotations.Suppress) return
val nameExpressions = argumentMapping[StandardClassIds.Annotations.ParameterNames.suppressNames]?.unwrapVarargValue() ?: return
for (nameExpression in nameExpressions) {
val name = (nameExpression as? FirConstExpression<*>)?.value as? String ?: continue
val name = (nameExpression as? FirLiteralExpression<*>)?.value as? String ?: continue
val parameter = when (name) {
in FIR_NON_SUPPRESSIBLE_ERROR_NAMES -> name
AbstractDiagnosticCollector.SUPPRESS_ALL_ERRORS -> "all errors"
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirDivisionByZeroChecker.kt
+2 -2
View File
@@ -10,7 +10,7 @@ import org.jetbrains.kotlin.diagnostics.reportOn
import org.jetbrains.kotlin.fir.analysis.checkers.MppCheckerKind
import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
import org.jetbrains.kotlin.fir.expressions.FirConstExpression
import org.jetbrains.kotlin.fir.expressions.FirLiteralExpression
import org.jetbrains.kotlin.fir.expressions.FirFunctionCall
import org.jetbrains.kotlin.fir.expressions.arguments
import org.jetbrains.kotlin.fir.references.toResolvedNamedFunctionSymbol
@@ -22,7 +22,7 @@ object FirDivisionByZeroChecker : FirFunctionCallChecker(MppCheckerKind.Common)
private val defaultDivName = Name.identifier("div")
override fun check(expression: FirFunctionCall, context: CheckerContext, reporter: DiagnosticReporter) {
val firstValue = (expression.arguments.singleOrNull() as? FirConstExpression<*>)?.value
val firstValue = (expression.arguments.singleOrNull() as? FirLiteralExpression<*>)?.value
if (firstValue != null && (firstValue == 0L || firstValue == 0.0f || firstValue == 0.0)) {
val callableId = (expression.calleeReference.toResolvedNamedFunctionSymbol())?.callableId
if (callableId != null && callableId.packageName == defaultPackageName && callableId.callableName == defaultDivName) {
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirOptInUsageBaseChecker.kt
+2 -2
View File
@@ -19,7 +19,7 @@ import org.jetbrains.kotlin.fir.declarations.*
import org.jetbrains.kotlin.fir.declarations.utils.correspondingValueParameterFromPrimaryConstructor
import org.jetbrains.kotlin.fir.declarations.utils.isData
import org.jetbrains.kotlin.fir.declarations.utils.nameOrSpecialName
import org.jetbrains.kotlin.fir.expressions.FirConstExpression
import org.jetbrains.kotlin.fir.expressions.FirLiteralExpression
import org.jetbrains.kotlin.fir.expressions.toReference
import org.jetbrains.kotlin.fir.references.FirErrorNamedReference
import org.jetbrains.kotlin.fir.references.FirNamedReference
@@ -281,7 +281,7 @@ object FirOptInUsageBaseChecker {
val levelName = levelArgument?.extractEnumValueArgumentInfo()?.enumEntryName?.asString()
val severity = Experimentality.Severity.entries.firstOrNull { it.name == levelName } ?: Experimentality.DEFAULT_SEVERITY
val message = (experimental.findArgumentByName(MESSAGE) as? FirConstExpression<*>)?.value as? String
val message = (experimental.findArgumentByName(MESSAGE) as? FirLiteralExpression<*>)?.value as? String
return Experimentality(symbol.classId, severity, message, annotatedOwnerClassName)
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirWhenConditionChecker.kt
+1 -1
View File
@@ -42,7 +42,7 @@ object FirWhenConditionChecker : FirWhenExpressionChecker(MppCheckerKind.Common)
val arguments = condition.arguments
if (arguments.size == 2 && arguments[0].unwrapSmartcastExpression() is FirWhenSubjectExpression) {
val value = when (val targetExpression = arguments[1]) {
is FirConstExpression<*> -> targetExpression.value
is FirLiteralExpression<*> -> targetExpression.value
is FirQualifiedAccessExpression -> targetExpression.calleeReference.toResolvedCallableSymbol() as? FirEnumEntrySymbol
?: continue
is FirResolvedQualifier -> {
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/extended/EmptyRangeChecker.kt
+3 -3
View File
@@ -12,7 +12,7 @@ import org.jetbrains.kotlin.fir.analysis.checkers.MppCheckerKind
import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
import org.jetbrains.kotlin.fir.analysis.checkers.expression.FirFunctionCallChecker
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
import org.jetbrains.kotlin.fir.expressions.FirConstExpression
import org.jetbrains.kotlin.fir.expressions.FirLiteralExpression
import org.jetbrains.kotlin.fir.expressions.FirFunctionCall
object EmptyRangeChecker : FirFunctionCallChecker(MppCheckerKind.Common) {
@@ -41,12 +41,12 @@ object EmptyRangeChecker : FirFunctionCallChecker(MppCheckerKind.Common) {
private val FirFunctionCall.rangeLeft: Long?
get() {
return (explicitReceiver as? FirConstExpression<*>)?.value as? Long
return (explicitReceiver as? FirLiteralExpression<*>)?.value as? Long
}
private val FirFunctionCall.rangeRight: Long?
get() {
val arg = argumentList.arguments.getOrNull(0) as? FirConstExpression<*>
val arg = argumentList.arguments.getOrNull(0) as? FirLiteralExpression<*>
return arg?.value as? Long
}
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/extended/RedundantCallOfConversionMethod.kt
+2 -2
View File
@@ -12,7 +12,7 @@ import org.jetbrains.kotlin.fir.analysis.checkers.MppCheckerKind
import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
import org.jetbrains.kotlin.fir.analysis.checkers.expression.FirQualifiedAccessExpressionChecker
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
import org.jetbrains.kotlin.fir.expressions.FirConstExpression
import org.jetbrains.kotlin.fir.expressions.FirLiteralExpression
import org.jetbrains.kotlin.fir.expressions.FirExpression
import org.jetbrains.kotlin.fir.expressions.FirFunctionCall
import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessExpression
@@ -38,7 +38,7 @@ object RedundantCallOfConversionMethod : FirQualifiedAccessExpressionChecker(Mpp
}
private fun FirExpression.isRedundant(qualifiedClassId: ClassId, session: FirSession): Boolean {
val thisType = if (this is FirConstExpression<*>) {
val thisType = if (this is FirLiteralExpression<*>) {
this.resolvedType.classId
} else {
when {
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/extended/RedundantExplicitTypeChecker.kt
+1 -1
View File
@@ -38,7 +38,7 @@ object RedundantExplicitTypeChecker : FirPropertyChecker(MppCheckerKind.Common)
if (typeReference.annotations.isNotEmpty()) return
when (initializer) {
is FirConstExpression<*> -> {
is FirLiteralExpression<*> -> {
when (initializer.source?.elementType) {
KtNodeTypes.BOOLEAN_CONSTANT -> {
if (!type.isSame(StandardClassIds.Boolean)) return
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/type/FirDuplicateParameterNameInFunctionTypeChecker.kt
+2 -2
View File
@@ -12,7 +12,7 @@ import org.jetbrains.kotlin.fir.analysis.checkers.MppCheckerKind
import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
import org.jetbrains.kotlin.fir.declarations.getAnnotationByClassId
import org.jetbrains.kotlin.fir.expressions.FirConstExpression
import org.jetbrains.kotlin.fir.expressions.FirLiteralExpression
import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
import org.jetbrains.kotlin.fir.types.FirTypeRef
import org.jetbrains.kotlin.fir.types.customAnnotations
@@ -26,7 +26,7 @@ object FirDuplicateParameterNameInFunctionTypeChecker : FirTypeRefChecker(MppChe
val type = it.type ?: return@groupBy null
val annotation = type.customAnnotations.getAnnotationByClassId(StandardNames.FqNames.parameterNameClassId, context.session)
val nameEntry = annotation?.argumentMapping?.mapping?.get(StandardNames.NAME)
(nameEntry as? FirConstExpression<*>)?.value as? String
(nameEntry as? FirLiteralExpression<*>)?.value as? String
}
for ((name, projections) in nameToArgumentProjection) {
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/AbstractDiagnosticCollector.kt
+2 -2
View File
@@ -11,7 +11,7 @@ import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.declarations.FirDeclaration
import org.jetbrains.kotlin.fir.declarations.findArgumentByName
import org.jetbrains.kotlin.fir.declarations.unwrapVarargValue
import org.jetbrains.kotlin.fir.expressions.FirConstExpression
import org.jetbrains.kotlin.fir.expressions.FirLiteralExpression
import org.jetbrains.kotlin.fir.resolve.ScopeSession
import org.jetbrains.kotlin.fir.resolve.SessionHolder
import org.jetbrains.kotlin.fir.symbols.lazyDeclarationResolver
@@ -60,7 +60,7 @@ abstract class AbstractDiagnosticCollector(
?: continue
for (argumentValue in argumentValues) {
val value = (argumentValue as? FirConstExpression<*>)?.value as? String ?: continue
val value = (argumentValue as? FirLiteralExpression<*>)?.value as? String ?: continue
if (result == null) {
result = mutableListOf()
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/components/ExpressionCheckersDiagnosticComponent.kt
+2 -2
View File
@@ -46,8 +46,8 @@ class ExpressionCheckersDiagnosticComponent(
checkers.allTypeOperatorCallCheckers.check(typeOperatorCall, data)
}
override fun <T> visitConstExpression(constExpression: FirConstExpression<T>, data: CheckerContext) {
checkers.allConstExpressionCheckers.check(constExpression, data)
override fun <T> visitLiteralExpression(literalExpression: FirLiteralExpression<T>, data: CheckerContext) {
checkers.allLiteralExpressionCheckers.check(literalExpression, data)
}
override fun visitAnnotation(annotation: FirAnnotation, data: CheckerContext) {
compiler/fir/dump/src/org/jetbrains/kotlin/fir/dump/HtmlFirDump.kt
+2 -2
View File
@@ -759,7 +759,7 @@ class HtmlFirDump internal constructor(private var linkResolver: FirLinkResolver
}
}
private fun FlowContent.generate(expression: FirConstExpression<*>) {
private fun FlowContent.generate(expression: FirLiteralExpression<*>) {
val value = expression.value
if (value == null && expression.kind != ConstantValueKind.Null) {
return error {
@@ -1545,7 +1545,7 @@ class HtmlFirDump internal constructor(private var linkResolver: FirLinkResolver
is FirElseIfTrueCondition -> generate(expression)
is FirWhenExpression -> generate(expression, isStatement = false)
is FirTryExpression -> generate(expression, isStatement = false)
is FirConstExpression<*> -> generate(expression)
is FirLiteralExpression<*> -> generate(expression)
is FirReturnExpression -> {
span("return-label") {
symbolRef(expression.target.labeledElement.symbol) {
compiler/fir/fir-deserialization/src/org/jetbrains/kotlin/fir/deserialization/AbstractAnnotationDeserializer.kt
+2 -2
View File
@@ -298,7 +298,7 @@ abstract class AbstractAnnotationDeserializer(
}
}
private fun <T> const(kind: ConstantValueKind<T>, value: T, typeRef: FirResolvedTypeRef): FirConstExpression<T> {
return buildConstExpression(null, kind, value, setType = true).apply { this.replaceConeTypeOrNull(typeRef.coneType) }
private fun <T> const(kind: ConstantValueKind<T>, value: T, typeRef: FirResolvedTypeRef): FirLiteralExpression<T> {
return buildLiteralExpression(null, kind, value, setType = true).apply { this.replaceConeTypeOrNull(typeRef.coneType) }
}
}
compiler/fir/fir-deserialization/src/org/jetbrains/kotlin/fir/deserialization/FirConstDeserializer.kt
+10 -10
View File
@@ -7,7 +7,7 @@ package org.jetbrains.kotlin.fir.deserialization
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.expressions.FirExpression
import org.jetbrains.kotlin.fir.expressions.builder.buildConstExpression
import org.jetbrains.kotlin.fir.expressions.builder.buildLiteralExpression
import org.jetbrains.kotlin.metadata.ProtoBuf
import org.jetbrains.kotlin.metadata.deserialization.Flags
import org.jetbrains.kotlin.metadata.deserialization.NameResolver
@@ -35,31 +35,31 @@ fun buildFirConstant(
protoValue: ProtoBuf.Annotation.Argument.Value?, sourceValue: Any?, constKind: String, nameResolver: NameResolver
): FirExpression? {
return when (constKind) {
"BYTE", "B" -> buildConstExpression(
"BYTE", "B" -> buildLiteralExpression(
null, ConstantValueKind.Byte, ((protoValue?.intValue ?: sourceValue) as Number).toByte(), setType = true
)
"CHAR", "C" -> buildConstExpression(
"CHAR", "C" -> buildLiteralExpression(
null, ConstantValueKind.Char, ((protoValue?.intValue ?: sourceValue) as Number).toInt().toChar(), setType = true
)
"SHORT", "S" -> buildConstExpression(
"SHORT", "S" -> buildLiteralExpression(
null, ConstantValueKind.Short, ((protoValue?.intValue ?: sourceValue) as Number).toShort(), setType = true
)
"INT", "I" -> buildConstExpression(
"INT", "I" -> buildLiteralExpression(
null, ConstantValueKind.Int, protoValue?.intValue?.toInt() ?: sourceValue as Int, setType = true
)
"LONG", "J" -> buildConstExpression(
"LONG", "J" -> buildLiteralExpression(
null, ConstantValueKind.Long, protoValue?.intValue ?: sourceValue as Long, setType = true
)
"FLOAT", "F" -> buildConstExpression(
"FLOAT", "F" -> buildLiteralExpression(
null, ConstantValueKind.Float, protoValue?.floatValue ?: sourceValue as Float, setType = true
)
"DOUBLE", "D" -> buildConstExpression(
"DOUBLE", "D" -> buildLiteralExpression(
null, ConstantValueKind.Double, protoValue?.doubleValue ?: sourceValue as Double, setType = true
)
"BOOLEAN", "Z" -> buildConstExpression(
"BOOLEAN", "Z" -> buildLiteralExpression(
null, ConstantValueKind.Boolean, (protoValue?.intValue?.toInt() ?: sourceValue) != 0, setType = true
)
"STRING", "Ljava/lang/String;" -> buildConstExpression(
"STRING", "Ljava/lang/String;" -> buildLiteralExpression(
null, ConstantValueKind.String,
protoValue?.stringValue?.let { nameResolver.getString(it) } ?: sourceValue as String, setType = true
)
compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/FirElementSerializer.kt
+2 -2
View File
@@ -28,7 +28,7 @@ import org.jetbrains.kotlin.fir.deserialization.projection
import org.jetbrains.kotlin.fir.expressions.*
import org.jetbrains.kotlin.fir.expressions.builder.buildAnnotation
import org.jetbrains.kotlin.fir.expressions.builder.buildAnnotationArgumentMapping
import org.jetbrains.kotlin.fir.expressions.builder.buildConstExpression
import org.jetbrains.kotlin.fir.expressions.builder.buildLiteralExpression
import org.jetbrains.kotlin.fir.expressions.impl.FirEmptyAnnotationArgumentMapping
import org.jetbrains.kotlin.fir.extensions.FirExtensionApiInternals
import org.jetbrains.kotlin.fir.extensions.extensionService
@@ -938,7 +938,7 @@ class FirElementSerializer private constructor(
correspondingTypeRef?.annotations, CompilerConeAttributes.ContextFunctionTypeParams.ANNOTATION_CLASS_ID,
argumentMapping = buildAnnotationArgumentMapping {
this.mapping[StandardNames.CONTEXT_FUNCTION_TYPE_PARAMETER_COUNT_NAME] =
buildConstExpression(
buildLiteralExpression(
source = null, ConstantValueKind.Int, type.contextReceiversNumberForFunctionType, setType = false
)
}
compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/constant/FirToConstantValueTransformer.kt
+7 -7
View File
@@ -60,12 +60,12 @@ internal object FirToConstantValueTransformer : FirDefaultVisitor<ConstantValue<
error("Illegal element as annotation argument: ${element::class.qualifiedName} -> ${element.render()}")
}
override fun <T> visitConstExpression(
constExpression: FirConstExpression<T>,
override fun <T> visitLiteralExpression(
literalExpression: FirLiteralExpression<T>,
data: FirToConstantValueTransformerData
): ConstantValue<*>? {
val value = constExpression.value
return when (constExpression.kind) {
val value = literalExpression.value
return when (literalExpression.kind) {
ConstantValueKind.Boolean -> BooleanValue(value as Boolean)
ConstantValueKind.Char -> CharValue(value as Char)
ConstantValueKind.Byte -> ByteValue((value as Number).toByte())
@@ -250,11 +250,11 @@ internal object FirToConstantValueChecker : FirDefaultVisitor<Boolean, FirSessio
return false
}
override fun <T> visitConstExpression(
constExpression: FirConstExpression<T>,
override fun <T> visitLiteralExpression(
literalExpression: FirLiteralExpression<T>,
data: FirSession
): Boolean {
return constExpression.kind in supportedConstKinds
return literalExpression.kind in supportedConstKinds
}
override fun visitStringConcatenationCall(stringConcatenationCall: FirStringConcatenationCall, data: FirSession): Boolean {
compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/ConversionUtils.kt
+2 -2
View File
@@ -333,7 +333,7 @@ fun FirCallableSymbol<*>.toSymbolForCall(
}
}
fun FirConstExpression<*>.getIrConstKind(): IrConstKind<*> = when (kind) {
fun FirLiteralExpression<*>.getIrConstKind(): IrConstKind<*> = when (kind) {
ConstantValueKind.IntegerLiteral, ConstantValueKind.UnsignedIntegerLiteral -> {
val type = resolvedType as ConeIntegerLiteralType
type.getApproximatedType().toConstKind()!!.toIrConstKind()
@@ -342,7 +342,7 @@ fun FirConstExpression<*>.getIrConstKind(): IrConstKind<*> = when (kind) {
else -> kind.toIrConstKind()
}
fun <T> FirConstExpression<T>.toIrConst(irType: IrType): IrConst<T> {
fun <T> FirLiteralExpression<T>.toIrConst(irType: IrType): IrConst<T> {
return convertWithOffsets { startOffset, endOffset ->
@Suppress("UNCHECKED_CAST")
val kind = getIrConstKind() as IrConstKind<T>
compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrImplicitCastInserter.kt
+1 -1
View File
@@ -62,7 +62,7 @@ class Fir2IrImplicitCastInserter(
override fun visitEqualityOperatorCall(equalityOperatorCall: FirEqualityOperatorCall, data: IrElement): IrElement = data
override fun <T> visitConstExpression(constExpression: FirConstExpression<T>, data: IrElement): IrElement = data
override fun <T> visitLiteralExpression(literalExpression: FirLiteralExpression<T>, data: IrElement): IrElement = data
override fun visitThisReceiverExpression(thisReceiverExpression: FirThisReceiverExpression, data: IrElement): IrElement = data
compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrIrGeneratedDeclarationsRegistrar.kt
+11 -11
View File
@@ -16,7 +16,7 @@ import org.jetbrains.kotlin.fir.declarations.utils.classId
import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.expressions.builder.buildAnnotation
import org.jetbrains.kotlin.fir.expressions.builder.buildAnnotationArgumentMapping
import org.jetbrains.kotlin.fir.expressions.builder.buildConstExpression
import org.jetbrains.kotlin.fir.expressions.builder.buildLiteralExpression
import org.jetbrains.kotlin.fir.expressions.builder.buildExpressionStub
import org.jetbrains.kotlin.fir.resolve.defaultType
import org.jetbrains.kotlin.fir.resolve.providers.getContainingFile
@@ -280,61 +280,61 @@ class Fir2IrIrGeneratedDeclarationsRegistrar(private val components: Fir2IrCompo
val name = this@toFirAnnotation.symbol.owner.valueParameters[i].name
val argument = this@toFirAnnotation.getValueArgument(i) as IrConst<*>
this.mapping[name] = when (argument.kind) {
IrConstKind.Boolean -> buildConstExpression(
IrConstKind.Boolean -> buildLiteralExpression(
source = null,
ConstantValueKind.Boolean,
argument.value as Boolean,
setType = true
)
IrConstKind.Byte -> buildConstExpression(
IrConstKind.Byte -> buildLiteralExpression(
source = null,
ConstantValueKind.Byte,
argument.value as Byte,
setType = true
)
IrConstKind.Char -> buildConstExpression(
IrConstKind.Char -> buildLiteralExpression(
source = null,
ConstantValueKind.Char,
argument.value as Char,
setType = true
)
IrConstKind.Double -> buildConstExpression(
IrConstKind.Double -> buildLiteralExpression(
source = null,
ConstantValueKind.Double,
argument.value as Double,
setType = true
)
IrConstKind.Float -> buildConstExpression(
IrConstKind.Float -> buildLiteralExpression(
source = null,
ConstantValueKind.Float,
argument.value as Float,
setType = true
)
IrConstKind.Int -> buildConstExpression(
IrConstKind.Int -> buildLiteralExpression(
source = null,
ConstantValueKind.Int,
argument.value as Int,
setType = true
)
IrConstKind.Long -> buildConstExpression(
IrConstKind.Long -> buildLiteralExpression(
source = null,
ConstantValueKind.Long,
argument.value as Long,
setType = true
)
IrConstKind.Null -> buildConstExpression(
IrConstKind.Null -> buildLiteralExpression(
source = null,
ConstantValueKind.Null,
value = null,
setType = true
)
IrConstKind.Short -> buildConstExpression(
IrConstKind.Short -> buildLiteralExpression(
source = null,
ConstantValueKind.Short,
argument.value as Short,
setType = false
)
IrConstKind.String -> buildConstExpression(
IrConstKind.String -> buildLiteralExpression(
source = null,
ConstantValueKind.String,
argument.value as String,
compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrVisitor.kt
+2 -2
View File
@@ -876,8 +876,8 @@ class Fir2IrVisitor(
return desugaredAssignmentValueReferenceExpression.expressionRef.value.accept(this, null)
}
override fun <T> visitConstExpression(constExpression: FirConstExpression<T>, data: Any?): IrElement {
return constExpression.toIrConst(constExpression.resolvedType.toIrType())
override fun <T> visitLiteralExpression(literalExpression: FirLiteralExpression<T>, data: Any?): IrElement {
return literalExpression.toIrConst(literalExpression.resolvedType.toIrType())
}
// ==================================================================================
compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/Fir2IrCallableDeclarationsGenerator.kt
+4 -4
View File
@@ -15,7 +15,7 @@ import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertySetter
import org.jetbrains.kotlin.fir.declarations.utils.*
import org.jetbrains.kotlin.fir.descriptors.FirModuleDescriptor
import org.jetbrains.kotlin.fir.descriptors.FirPackageFragmentDescriptor
import org.jetbrains.kotlin.fir.expressions.FirConstExpression
import org.jetbrains.kotlin.fir.expressions.FirLiteralExpression
import org.jetbrains.kotlin.fir.expressions.FirExpression
import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessExpression
import org.jetbrains.kotlin.fir.expressions.impl.FirExpressionStub
@@ -312,7 +312,7 @@ class Fir2IrCallableDeclarationsGenerator(val components: Fir2IrComponents) : Fi
initializer,
typeToUse
).also { field ->
if (initializer is FirConstExpression<*>) {
if (initializer is FirLiteralExpression<*>) {
val constType = initializer.resolvedType.toIrType()
field.initializer = factory.createExpressionBody(initializer.toIrConst(constType))
}
@@ -368,7 +368,7 @@ class Fir2IrCallableDeclarationsGenerator(val components: Fir2IrComponents) : Fi
private fun getEffectivePropertyInitializer(property: FirProperty, resolveIfNeeded: Boolean): FirExpression? {
val initializer = property.backingField?.initializer ?: property.initializer
if (resolveIfNeeded && initializer is FirConstExpression<*>) {
if (resolveIfNeeded && initializer is FirLiteralExpression<*>) {
property.lazyResolveToPhase(FirResolvePhase.BODY_RESOLVE)
return getEffectivePropertyInitializer(property, resolveIfNeeded = false)
}
@@ -558,7 +558,7 @@ class Fir2IrCallableDeclarationsGenerator(val components: Fir2IrComponents) : Fi
).apply {
metadata = FirMetadataSource.Field(field)
val initializer = field.unwrapFakeOverrides().initializer
if (initializer is FirConstExpression<*>) {
if (initializer is FirLiteralExpression<*>) {
this.initializer = factory.createExpressionBody(initializer.toIrConst(irType))
}
/*
compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/lazy/Fir2IrLazyField.kt
+2 -2
View File
@@ -15,7 +15,7 @@ import org.jetbrains.kotlin.fir.declarations.utils.isExternal
import org.jetbrains.kotlin.fir.declarations.utils.isFinal
import org.jetbrains.kotlin.fir.declarations.utils.isStatic
import org.jetbrains.kotlin.fir.declarations.utils.visibility
import org.jetbrains.kotlin.fir.expressions.FirConstExpression
import org.jetbrains.kotlin.fir.expressions.FirLiteralExpression
import org.jetbrains.kotlin.fir.unwrapFakeOverrides
import org.jetbrains.kotlin.ir.ObsoleteDescriptorBasedAPI
import org.jetbrains.kotlin.ir.declarations.*
@@ -72,7 +72,7 @@ class Fir2IrLazyField(
override var initializer: IrExpressionBody? by lazyVar(lock) {
when (val initializer = fir.unwrapFakeOverrides().initializer) {
is FirConstExpression<*> -> factory.createExpressionBody(initializer.toIrConst(type))
is FirLiteralExpression<*> -> factory.createExpressionBody(initializer.toIrConst(type))
else -> null
}
}
compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/lazy/Fir2IrLazyProperty.kt
+2 -2
View File
@@ -16,7 +16,7 @@ import org.jetbrains.kotlin.fir.declarations.FirRegularClass
import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyGetter
import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertySetter
import org.jetbrains.kotlin.fir.declarations.utils.*
import org.jetbrains.kotlin.fir.expressions.FirConstExpression
import org.jetbrains.kotlin.fir.expressions.FirLiteralExpression
import org.jetbrains.kotlin.fir.expressions.FirExpression
import org.jetbrains.kotlin.fir.types.coneType
import org.jetbrains.kotlin.fir.types.resolvedType
@@ -100,7 +100,7 @@ class Fir2IrLazyProperty(
components, fir.returnTypeRef.coneType
)
// Setting initializers to every other class causes some cryptic errors in lowerings
initializer is FirConstExpression<*> -> {
initializer is FirLiteralExpression<*> -> {
val constType = with(typeConverter) { initializer.resolvedType.toIrType() }
factory.createExpressionBody(initializer.toIrConst(constType))
}
compiler/fir/java/src/org/jetbrains/kotlin/fir/java/FirJavaElementFinder.kt
+2 -2
View File
@@ -34,7 +34,7 @@ import org.jetbrains.kotlin.fir.caches.getValue
import org.jetbrains.kotlin.fir.declarations.*
import org.jetbrains.kotlin.fir.declarations.utils.*
import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.expressions.FirConstExpression
import org.jetbrains.kotlin.fir.expressions.FirLiteralExpression
import org.jetbrains.kotlin.fir.moduleData
import org.jetbrains.kotlin.fir.resolve.ScopeSession
import org.jetbrains.kotlin.fir.resolve.fullyExpandedType
@@ -132,7 +132,7 @@ class FirJavaElementFinder(
private fun FirFile.jvmName(): String {
val jvmNameAnnotation = this.findJvmNameAnnotation()
val jvmName = jvmNameAnnotation?.findArgumentByName(StandardNames.NAME)
val jvmNameValue = (jvmName as? FirConstExpression<*>)?.value as? String
val jvmNameValue = (jvmName as? FirLiteralExpression<*>)?.value as? String
return jvmNameValue ?: (this.name.removeSuffix(".kt").capitalizeAsciiOnly() + "Kt")
}
compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaUtils.kt
+11 -11
View File
@@ -18,7 +18,7 @@ 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.buildArrayLiteral
import org.jetbrains.kotlin.fir.expressions.builder.buildConstExpression
import org.jetbrains.kotlin.fir.expressions.builder.buildLiteralExpression
import org.jetbrains.kotlin.fir.expressions.builder.buildErrorExpression
import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.expectedConeType
import org.jetbrains.kotlin.fir.types.*
@@ -77,31 +77,31 @@ internal fun Any?.createConstantOrError(session: FirSession, expectedTypeRef: Fi
internal fun Any?.createConstantIfAny(session: FirSession, unsigned: Boolean = false): FirExpression? {
return when (this) {
is Byte -> buildConstExpression(
is Byte -> buildLiteralExpression(
null, if (unsigned) ConstantValueKind.UnsignedByte else ConstantValueKind.Byte, this, setType = true
)
is Short -> buildConstExpression(
is Short -> buildLiteralExpression(
null, if (unsigned) ConstantValueKind.UnsignedShort else ConstantValueKind.Short, this, setType = true
)
is Int -> buildConstExpression(
is Int -> buildLiteralExpression(
null, if (unsigned) ConstantValueKind.UnsignedInt else ConstantValueKind.Int, this, setType = true
)
is Long -> buildConstExpression(
is Long -> buildLiteralExpression(
null, if (unsigned) ConstantValueKind.UnsignedLong else ConstantValueKind.Long, this, setType = true
)
is Char -> buildConstExpression(
is Char -> buildLiteralExpression(
null, ConstantValueKind.Char, this, setType = true
)
is Float -> buildConstExpression(
is Float -> buildLiteralExpression(
null, ConstantValueKind.Float, this, setType = true
)
is Double -> buildConstExpression(
is Double -> buildLiteralExpression(
null, ConstantValueKind.Double, this, setType = true
)
is Boolean -> buildConstExpression(
is Boolean -> buildLiteralExpression(
null, ConstantValueKind.Boolean, this, setType = true
)
is String -> buildConstExpression(
is String -> buildLiteralExpression(
null, ConstantValueKind.String, this, setType = true
)
is ByteArray -> toList().createArrayLiteral(session, ConstantValueKind.Byte)
@@ -112,7 +112,7 @@ internal fun Any?.createConstantIfAny(session: FirSession, unsigned: Boolean = f
is FloatArray -> toList().createArrayLiteral(session, ConstantValueKind.Float)
is DoubleArray -> toList().createArrayLiteral(session, ConstantValueKind.Double)
is BooleanArray -> toList().createArrayLiteral(session, ConstantValueKind.Boolean)
null -> buildConstExpression(
null -> buildLiteralExpression(
null, ConstantValueKind.Null, null, setType = true
)
compiler/fir/java/src/org/jetbrains/kotlin/fir/java/deserialization/JvmBinaryAnnotationDeserializer.kt
+2 -2
View File
@@ -10,7 +10,7 @@ import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.deserialization.AbstractAnnotationDeserializer
import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.expressions.FirConstExpression
import org.jetbrains.kotlin.fir.expressions.FirLiteralExpression
import org.jetbrains.kotlin.fir.expressions.FirExpression
import org.jetbrains.kotlin.fir.expressions.builder.buildAnnotation
import org.jetbrains.kotlin.fir.java.createConstantIfAny
@@ -216,7 +216,7 @@ class JvmBinaryAnnotationDeserializer(
): FirExpression? {
val signature = getCallableSignature(propertyProto, nameResolver, typeTable, CallableKind.PROPERTY_GETTER) ?: return null
val firExpr = annotationInfo.annotationMethodsDefaultValues[signature]
return if (firExpr is FirConstExpression<*> && expectedPropertyType.coneType.isUnsignedType && firExpr.kind.isSignedNumber)
return if (firExpr is FirLiteralExpression<*> && expectedPropertyType.coneType.isUnsignedType && firExpr.kind.isSignedNumber)
firExpr.value.createConstantIfAny(session, unsigned = true)
else
firExpr
compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/SignatureEnhancement.kt
+2 -2
View File
@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.fir.declarations.synthetic.FirSyntheticProperty
import org.jetbrains.kotlin.fir.declarations.synthetic.buildSyntheticProperty
import org.jetbrains.kotlin.fir.declarations.utils.*
import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.expressions.FirConstExpression
import org.jetbrains.kotlin.fir.expressions.FirLiteralExpression
import org.jetbrains.kotlin.fir.expressions.unexpandedClassId
import org.jetbrains.kotlin.fir.java.FirJavaTypeConversionMode
import org.jetbrains.kotlin.fir.java.JavaTypeParameterStack
@@ -533,7 +533,7 @@ class FirSignatureEnhancement(
private fun getPurelyImplementedSupertype(session: FirSession): ConeKotlinType? {
val purelyImplementedClassIdFromAnnotation = owner.annotations
.firstOrNull { it.unexpandedClassId?.asSingleFqName() == JvmAnnotationNames.PURELY_IMPLEMENTS_ANNOTATION }
?.let { (it.argumentMapping.mapping.values.firstOrNull() as? FirConstExpression<*>) }
?.let { (it.argumentMapping.mapping.values.firstOrNull() as? FirLiteralExpression<*>) }
?.let { it.value as? String }
?.takeIf { it.isNotBlank() && isValidJavaFqName(it) }
?.let { ClassId.topLevel(FqName(it)) }
compiler/fir/native/src/org/jetbrains/kotlin/fir/backend/native/interop/FirObjCInterop.kt
+2 -2
View File
@@ -9,7 +9,7 @@ import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.containingClassLookupTag
import org.jetbrains.kotlin.fir.declarations.*
import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.expressions.FirConstExpression
import org.jetbrains.kotlin.fir.expressions.FirLiteralExpression
import org.jetbrains.kotlin.fir.resolve.*
import org.jetbrains.kotlin.fir.scopes.getDirectOverriddenFunctions
import org.jetbrains.kotlin.fir.scopes.impl.declaredMemberScope
@@ -88,7 +88,7 @@ private fun FirAnnotation.constBooleanArgumentOrNull(argumentName: String): Bool
constArgument(argumentName) as Boolean?
private fun FirAnnotation.constArgument(argumentName: String) =
(argumentMapping.mapping[Name.identifier(argumentName)] as? FirConstExpression<*>)?.value
(argumentMapping.mapping[Name.identifier(argumentName)] as? FirLiteralExpression<*>)?.value
internal fun FirFunction.hasObjCFactoryAnnotation(session: FirSession) = this.annotations.hasAnnotation(NativeStandardInteropNames.objCFactoryClassId, session)
compiler/fir/providers/src/org/jetbrains/kotlin/fir/CopyUtils.kt
+1 -1
View File
@@ -127,4 +127,4 @@ private fun FirAnnotation.tryExpandClassId(session: FirSession): ClassId? {
}
private fun FirAnnotation.extractContextReceiversCount() =
(argumentMapping.mapping[StandardNames.CONTEXT_FUNCTION_TYPE_PARAMETER_COUNT_NAME] as? FirConstExpression<*>)?.value as? Int
(argumentMapping.mapping[StandardNames.CONTEXT_FUNCTION_TYPE_PARAMETER_COUNT_NAME] as? FirLiteralExpression<*>)?.value as? Int
compiler/fir/providers/src/org/jetbrains/kotlin/fir/declarations/FirAnnotationUtils.kt
+2 -2
View File
@@ -141,12 +141,12 @@ fun FirAnnotation.getBooleanArgument(name: Name): Boolean? = getPrimitiveArgumen
fun FirAnnotation.getStringArgument(name: Name): String? = getPrimitiveArgumentValue(name)
fun FirAnnotation.getStringArrayArgument(name: Name): List<String>? {
val argument = findArgumentByName(name) as? FirArrayLiteral ?: return null
return argument.arguments.mapNotNull { (it as? FirConstExpression<*>)?.value as? String }
return argument.arguments.mapNotNull { (it as? FirLiteralExpression<*>)?.value as? String }
}
private inline fun <reified T> FirAnnotation.getPrimitiveArgumentValue(name: Name): T? {
return findArgumentByName(name)?.let { expression ->
(expression as? FirConstExpression<*>)?.value as? T
(expression as? FirLiteralExpression<*>)?.value as? T
}
}
compiler/fir/providers/src/org/jetbrains/kotlin/fir/declarations/deprecationUtils.kt
+2 -2
View File
@@ -273,7 +273,7 @@ private fun List<FirAnnotation>.extractDeprecationAnnotationInfoPerUseSite(
for ((deprecated, shouldPropagateToOverrides) in annotations) {
if (deprecated.unexpandedClassId == StandardClassIds.Annotations.SinceKotlin) {
val sinceKotlinSingleArgument = deprecated.findArgumentByName(ParameterNames.sinceKotlinVersion)
val apiVersion = ((sinceKotlinSingleArgument as? FirConstExpression<*>)?.value as? String)
val apiVersion = ((sinceKotlinSingleArgument as? FirLiteralExpression<*>)?.value as? String)
?.let(ApiVersion.Companion::parse) ?: continue
val wasExperimental = this@extractDeprecationAnnotationInfoPerUseSite.any {
it.unexpandedClassId == StandardClassIds.Annotations.WasExperimental
@@ -315,7 +315,7 @@ private fun List<FirAnnotation>.extractDeprecationAnnotationInfoPerUseSite(
private fun FirAnnotation.getFirstArgumentStringIfNotNamed(): String? {
if (this !is FirAnnotationCall) return null
val firstArgument = argumentList.arguments.firstOrNull() ?: return null
return (firstArgument as? FirConstExpression<*>)?.value?.toString()
return (firstArgument as? FirLiteralExpression<*>)?.value?.toString()
}
compiler/fir/providers/src/org/jetbrains/kotlin/fir/resolve/LookupTagUtils.kt
+2 -2
View File
@@ -16,7 +16,7 @@ import org.jetbrains.kotlin.fir.declarations.utils.isInner
import org.jetbrains.kotlin.fir.declarations.utils.isLocal
import org.jetbrains.kotlin.fir.expressions.builder.buildAnnotation
import org.jetbrains.kotlin.fir.expressions.builder.buildAnnotationArgumentMapping
import org.jetbrains.kotlin.fir.expressions.builder.buildConstExpression
import org.jetbrains.kotlin.fir.expressions.builder.buildLiteralExpression
import org.jetbrains.kotlin.fir.getContainingClassLookupTag
import org.jetbrains.kotlin.fir.resolve.providers.FirSymbolProvider
import org.jetbrains.kotlin.fir.resolve.providers.symbolProvider
@@ -109,7 +109,7 @@ fun ConeKotlinType.withParameterNameAnnotation(parameter: FirFunctionTypeParamet
}
argumentMapping = buildAnnotationArgumentMapping {
mapping[StandardClassIds.Annotations.ParameterNames.parameterNameName] =
buildConstExpression(fakeSource, ConstantValueKind.String, name.asString(), setType = true)
buildLiteralExpression(fakeSource, ConstantValueKind.String, name.asString(), setType = true)
}
}
val attributesWithParameterNameAnnotation =
compiler/fir/providers/src/org/jetbrains/kotlin/fir/types/ConeTypeContext.kt
+1 -1
View File
@@ -569,7 +569,7 @@ interface ConeTypeContext : TypeSystemContext, TypeSystemOptimizationContext, Ty
is FirNamedArgumentExpression -> argument.expression
else -> argument
} ?: return null
return (argument as? FirConstExpression<*>)?.value
return (argument as? FirLiteralExpression<*>)?.value
}
override fun TypeConstructorMarker.getTypeParameterClassifier(): TypeParameterMarker? {
compiler/fir/raw-fir/raw-fir.common/src/org/jetbrains/kotlin/fir/builder/AbstractRawFirBuilder.kt
+6 -6
View File
@@ -470,14 +470,14 @@ abstract class AbstractRawFirBuilder<T>(val baseSession: FirSession, val context
)
}
BOOLEAN_CONSTANT ->
buildConstExpression(
buildLiteralExpression(
sourceElement,
ConstantValueKind.Boolean,
convertedText as Boolean,
setType = false
)
NULL ->
buildConstExpression(
buildLiteralExpression(
sourceElement,
ConstantValueKind.Null,
null,
@@ -503,7 +503,7 @@ abstract class AbstractRawFirBuilder<T>(val baseSession: FirSession, val context
receiver: FirExpression,
operationToken: IElementType,
): FirExpression? {
if (receiver !is FirConstExpression<*>) return null
if (receiver !is FirLiteralExpression<*>) return null
if (receiver.kind != ConstantValueKind.IntegerLiteral) return null
if (operationToken != PLUS && operationToken != MINUS) return null
@@ -514,7 +514,7 @@ abstract class AbstractRawFirBuilder<T>(val baseSession: FirSession, val context
else -> error("Should not be here")
}
return buildConstExpression(
return buildLiteralExpression(
source.toFirSourceElement(),
ConstantValueKind.IntegerLiteral,
convertedValue,
@@ -537,7 +537,7 @@ abstract class AbstractRawFirBuilder<T>(val baseSession: FirSession, val context
OPEN_QUOTE, CLOSING_QUOTE -> continue@L
LITERAL_STRING_TEMPLATE_ENTRY -> {
sb.append(entry.asText)
buildConstExpression(
buildLiteralExpression(
entry.toFirSourceElement(), ConstantValueKind.String, entry.asText, setType = false
)
}
@@ -571,7 +571,7 @@ abstract class AbstractRawFirBuilder<T>(val baseSession: FirSession, val context
source = base?.toFirSourceElement()
// Fast-pass if there is no errors and non-const string expressions
if (!hasExpressions && !argumentList.arguments.any { it is FirErrorExpression })
return buildConstExpression(source, ConstantValueKind.String, sb.toString(), setType = false)
return buildLiteralExpression(source, ConstantValueKind.String, sb.toString(), setType = false)
}
}
compiler/fir/raw-fir/raw-fir.common/src/org/jetbrains/kotlin/fir/builder/ConversionUtils.kt
+1 -1
View File
@@ -363,7 +363,7 @@ fun <T> FirPropertyBuilder.generateAccessorsByDelegate(
}
coneTypeOrNull = context.dispatchReceiverTypesStack.last()
}
else -> buildConstExpression(null, ConstantValueKind.Null, null, setType = false)
else -> buildLiteralExpression(null, ConstantValueKind.Null, null, setType = false)
}
fun delegateAccess() = buildPropertyAccessExpression {
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirCallResolver.kt
+1 -1
View File
@@ -815,7 +815,7 @@ class FirCallResolver(
candidates.isEmpty() -> {
when {
name.asString() == "invoke" && explicitReceiver is FirConstExpression<*> ->
name.asString() == "invoke" && explicitReceiver is FirLiteralExpression<*> ->
ConeFunctionExpectedError(
explicitReceiver.value?.toString() ?: "",
explicitReceiver.resolvedType,
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ResolveUtils.kt
+1 -1
View File
@@ -563,7 +563,7 @@ fun FirExpression?.isIntegerLiteralOrOperatorCall(): Boolean {
returns(true) implies (this@isIntegerLiteralOrOperatorCall != null)
}
return when (this) {
is FirConstExpression<*> -> kind == ConstantValueKind.Int
is FirLiteralExpression<*> -> kind == ConstantValueKind.Int
|| kind == ConstantValueKind.IntegerLiteral
|| kind == ConstantValueKind.UnsignedInt
|| kind == ConstantValueKind.UnsignedIntegerLiteral
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/FirDataFlowAnalyzer.kt
+5 -5
View File
@@ -435,8 +435,8 @@ abstract class FirDataFlowAnalyzer(
val leftConst = when (leftOperand) {
is FirWhenSubjectExpression -> leftOperand.whenRef.value.subject
else -> leftOperand
} as? FirConstExpression<*>
val rightConst = rightOperand as? FirConstExpression<*>
} as? FirLiteralExpression<*>
val rightConst = rightOperand as? FirLiteralExpression<*>
val leftIsNullConst = leftConst?.kind == ConstantValueKind.Null
val rightIsNullConst = rightConst?.kind == ConstantValueKind.Null
val leftIsNull = leftIsNullConst || leftOperand.resolvedType.isNullableNothing && !rightIsNullConst
@@ -460,7 +460,7 @@ abstract class FirDataFlowAnalyzer(
flow: MutableFlow,
expression: FirEqualityOperatorCall,
operand: FirExpression,
const: FirConstExpression<*>,
const: FirLiteralExpression<*>,
isEq: Boolean
) {
if (const.kind == ConstantValueKind.Null) {
@@ -1020,7 +1020,7 @@ abstract class FirDataFlowAnalyzer(
}
}
fun exitConstExpression(constExpression: FirConstExpression<*>) {
fun exitConstExpression(constExpression: FirLiteralExpression<*>) {
if (constExpression.isResolved) return
graphBuilder.exitConstExpression(constExpression).mergeIncomingFlow()
}
@@ -1265,7 +1265,7 @@ abstract class FirDataFlowAnalyzer(
// For any predicate P(x), if P(v) != P(u ?: v) then u != null. In general this requires two levels of
// implications, but for constant v the logic system can handle some basic cases of P(x).
val rhs = (elvisExpression.rhs as? FirConstExpression<*>)?.value as? Boolean
val rhs = (elvisExpression.rhs as? FirLiteralExpression<*>)?.value as? Boolean
if (rhs != null) {
flow.addAllConditionally(elvisVariable eq !rhs, node.firstPreviousNode.getFlow(path))
}
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/cfg/ControlFlowGraphBuilder.kt
+6 -6
View File
@@ -966,7 +966,7 @@ class ControlFlowGraphBuilder {
fun exitWhileLoopCondition(loop: FirLoop): Pair<LoopConditionExitNode, LoopBlockEnterNode> {
val conditionExitNode = createLoopConditionExitNode(loop.condition).also { addNewSimpleNode(it) }
val conditionConstBooleanValue = loop.condition.booleanConstValue
val conditionConstBooleanValue = loop.condition.booleanLiteralValue
addEdge(conditionExitNode, loopExitNodes.getValue(loop), propagateDeadness = false, isDead = conditionConstBooleanValue == true)
val loopBlockEnterNode = createLoopBlockEnterNode(loop)
addNewSimpleNode(loopBlockEnterNode, conditionConstBooleanValue == false)
@@ -1008,7 +1008,7 @@ class ControlFlowGraphBuilder {
fun exitDoWhileLoop(loop: FirLoop): Pair<LoopConditionExitNode, LoopExitNode> {
loopConditionEnterNodes.remove(loop)
val conditionExitNode = createLoopConditionExitNode(loop.condition)
val conditionBooleanValue = loop.condition.booleanConstValue
val conditionBooleanValue = loop.condition.booleanLiteralValue
popAndAddEdge(conditionExitNode)
val blockEnterNode = lastNodes.pop()
require(blockEnterNode is LoopBlockEnterNode)
@@ -1041,7 +1041,7 @@ class ControlFlowGraphBuilder {
addNewSimpleNode(leftExitNode)
lastNodes.push(leftExitNode) // to create an exit edge later
val rhsNeverExecuted =
binaryLogicExpression.leftOperand.booleanConstValue == (binaryLogicExpression.kind != LogicOperationKind.AND)
binaryLogicExpression.leftOperand.booleanLiteralValue == (binaryLogicExpression.kind != LogicOperationKind.AND)
addNewSimpleNode(rightEnterNode, isDead = rhsNeverExecuted)
return leftExitNode to rightEnterNode
}
@@ -1054,14 +1054,14 @@ class ControlFlowGraphBuilder {
val rightNode = lastNodes.pop()
val leftNode = lastNodes.pop()
val rhsAlwaysExecuted =
binaryLogicExpression.leftOperand.booleanConstValue == (binaryLogicExpression.kind == LogicOperationKind.AND)
binaryLogicExpression.leftOperand.booleanLiteralValue == (binaryLogicExpression.kind == LogicOperationKind.AND)
addEdge(leftNode, exitNode, propagateDeadness = !rhsAlwaysExecuted, isDead = rhsAlwaysExecuted)
addEdge(rightNode, exitNode, propagateDeadness = rhsAlwaysExecuted)
lastNodes.push(exitNode)
return exitNode
}
private val FirExpression.booleanConstValue: Boolean? get() = (this as? FirConstExpression<*>)?.value as? Boolean?
private val FirExpression.booleanLiteralValue: Boolean? get() = (this as? FirLiteralExpression<*>)?.value as? Boolean?
// ----------------------------------- Try-catch-finally -----------------------------------
@@ -1330,7 +1330,7 @@ class ControlFlowGraphBuilder {
return node
}
fun exitConstExpression(constExpression: FirConstExpression<*>): ConstExpressionNode {
fun exitLiteralExpression(constExpression: FirLiteralExpression<*>): ConstExpressionNode {
return createConstExpressionNode(constExpression).also { addNewSimpleNode(it) }
}
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/cfg/ControlFlowGraphNodeBuilder.kt
+1 -1
View File
@@ -163,7 +163,7 @@ fun ControlFlowGraphBuilder.createElvisExitNode(fir: FirElvisExpression): ElvisE
fun ControlFlowGraphBuilder.createVariableDeclarationNode(fir: FirProperty): VariableDeclarationNode =
VariableDeclarationNode(currentGraph, fir, levelCounter)
fun ControlFlowGraphBuilder.createConstExpressionNode(fir: FirConstExpression<*>): ConstExpressionNode =
fun ControlFlowGraphBuilder.createConstExpressionNode(fir: FirLiteralExpression<*>): ConstExpressionNode =
ConstExpressionNode(currentGraph, fir, levelCounter)
fun ControlFlowGraphBuilder.createThrowExceptionNode(fir: FirThrowExpression): ThrowExceptionNode =
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirCallCompletionResultsWriterTransformer.kt
+6 -6
View File
@@ -938,16 +938,16 @@ class FirCallCompletionResultsWriterTransformer(
)
}
override fun <T> transformConstExpression(
constExpression: FirConstExpression<T>,
override fun <T> transformLiteralExpression(
literalExpression: FirLiteralExpression<T>,
data: ExpectedArgumentType?,
): FirStatement {
if (data == ExpectedArgumentType.NoApproximation) return constExpression
val expectedType = data?.getExpectedType(constExpression)
if (data == ExpectedArgumentType.NoApproximation) return literalExpression
val expectedType = data?.getExpectedType(literalExpression)
if (expectedType is ConeIntegerConstantOperatorType) {
return constExpression
return literalExpression
}
return constExpression.transformSingle(integerOperatorApproximator, expectedType)
return literalExpression.transformSingle(integerOperatorApproximator, expectedType)
}
override fun transformIntegerLiteralOperatorCall(
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirWhenExhaustivenessTransformer.kt
+1 -1
View File
@@ -271,7 +271,7 @@ private object WhenOnBooleanExhaustivenessChecker : WhenExhaustivenessChecker()
override fun visitEqualityOperatorCall(equalityOperatorCall: FirEqualityOperatorCall, data: Flags) {
if (equalityOperatorCall.operation.let { it == FirOperation.EQ || it == FirOperation.IDENTITY }) {
val argument = equalityOperatorCall.arguments[1]
if (argument is FirConstExpression<*>) {
if (argument is FirLiteralExpression<*>) {
when (argument.value) {
true -> data.containsTrue = true
false -> data.containsFalse = true
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/IntegerLiteralAndOperatorApproximationTransformer.kt
+7 -8
View File
@@ -10,10 +10,9 @@ import org.jetbrains.kotlin.fakeElement
import org.jetbrains.kotlin.fir.FirElement
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
import org.jetbrains.kotlin.fir.expressions.FirConstExpression
import org.jetbrains.kotlin.fir.expressions.FirLiteralExpression
import org.jetbrains.kotlin.fir.expressions.FirIntegerLiteralOperatorCall
import org.jetbrains.kotlin.fir.expressions.FirStatement
import org.jetbrains.kotlin.fir.expressions.UnresolvedExpressionTypeAccess
import org.jetbrains.kotlin.fir.expressions.builder.buildFunctionCall
import org.jetbrains.kotlin.fir.references.FirResolvedErrorReference
import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
@@ -58,17 +57,17 @@ class IntegerLiteralAndOperatorApproximationTransformer(
return element
}
override fun <T> transformConstExpression(
constExpression: FirConstExpression<T>,
override fun <T> transformLiteralExpression(
literalExpression: FirLiteralExpression<T>,
data: ConeKotlinType?,
): FirStatement {
val type = constExpression.resolvedType as? ConeIntegerLiteralType ?: return constExpression
val type = literalExpression.resolvedType as? ConeIntegerLiteralType ?: return literalExpression
val approximatedType = type.getApproximatedType(data?.fullyExpandedType(session))
constExpression.resultType = approximatedType
literalExpression.resultType = approximatedType
@Suppress("UNCHECKED_CAST")
val kind = approximatedType.toConstKind() as ConstantValueKind<T>
constExpression.replaceKind(kind)
return constExpression
literalExpression.replaceKind(kind)
return literalExpression
}
override fun transformIntegerLiteralOperatorCall(
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirAbstractBodyResolveTransformerDispatcher.kt
+4 -4
View File
@@ -299,13 +299,13 @@ abstract class FirAbstractBodyResolveTransformerDispatcher(
FirDeclarationsResolveTransformer::transformWrappedDelegateExpression,
)
override fun <T> transformConstExpression(
constExpression: FirConstExpression<T>,
override fun <T> transformLiteralExpression(
literalExpression: FirLiteralExpression<T>,
data: ResolutionMode,
): FirStatement = expressionTransformation(
constExpression,
literalExpression,
data,
FirExpressionsResolveTransformer::transformConstExpression,
FirExpressionsResolveTransformer::transformLiteralExpression,
)
override fun transformAnnotation(
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt
+14 -14
View File
@@ -1089,7 +1089,7 @@ open class FirExpressionsResolveTransformer(transformer: FirAbstractBodyResolveT
): FirStatement = whileAnalysing(session, getClassCall) {
getClassCall.transformAnnotations(transformer, ResolutionMode.ContextIndependent)
val arg = getClassCall.argument
val dataForLhs = if (arg is FirConstExpression<*>) {
val dataForLhs = if (arg is FirLiteralExpression<*>) {
withExpectedType(arg.kind.expectedConeType(session).toFirResolvedTypeRef())
} else {
ResolutionMode.ContextIndependent
@@ -1163,16 +1163,16 @@ open class FirExpressionsResolveTransformer(transformer: FirAbstractBodyResolveT
return true
}
override fun <T> transformConstExpression(
constExpression: FirConstExpression<T>,
override fun <T> transformLiteralExpression(
literalExpression: FirLiteralExpression<T>,
data: ResolutionMode,
): FirStatement {
constExpression.transformAnnotations(transformer, ResolutionMode.ContextIndependent)
literalExpression.transformAnnotations(transformer, ResolutionMode.ContextIndependent)
val type = when (val kind = constExpression.kind) {
val type = when (val kind = literalExpression.kind) {
ConstantValueKind.IntegerLiteral, ConstantValueKind.UnsignedIntegerLiteral -> {
val expressionType = ConeIntegerLiteralConstantTypeImpl.create(
constExpression.value as Long,
literalExpression.value as Long,
isTypePresent = { it.lookupTag.toSymbol(session) != null },
isUnsigned = kind == ConstantValueKind.UnsignedIntegerLiteral
)
@@ -1183,7 +1183,7 @@ open class FirExpressionsResolveTransformer(transformer: FirAbstractBodyResolveT
expressionType
}
expressionType is ConeClassLikeType -> {
constExpression.replaceKind(expressionType.toConstKind() as ConstantValueKind<T>)
literalExpression.replaceKind(expressionType.toConstKind() as ConstantValueKind<T>)
expressionType
}
data is ResolutionMode.ReceiverResolution && !data.forCallableReference -> {
@@ -1194,7 +1194,7 @@ open class FirExpressionsResolveTransformer(transformer: FirAbstractBodyResolveT
require(expressionType is ConeIntegerLiteralConstantTypeImpl)
val coneType = expectedTypeRef.coneTypeSafe<ConeKotlinType>()?.fullyExpandedType(session)
val approximatedType = expressionType.getApproximatedType(coneType)
constExpression.replaceKind(approximatedType.toConstKind() as ConstantValueKind<T>)
literalExpression.replaceKind(approximatedType.toConstKind() as ConstantValueKind<T>)
approximatedType
}
else -> {
@@ -1205,17 +1205,17 @@ open class FirExpressionsResolveTransformer(transformer: FirAbstractBodyResolveT
else -> kind.expectedConeType(session)
}
dataFlowAnalyzer.exitConstExpression(constExpression as FirConstExpression<*>)
constExpression.resultType = type
dataFlowAnalyzer.exitConstExpression(literalExpression as FirLiteralExpression<*>)
literalExpression.resultType = type
return when (val resolvedType = constExpression.resolvedType) {
return when (val resolvedType = literalExpression.resolvedType) {
is ConeErrorType -> buildErrorExpression {
expression = constExpression
expression = literalExpression
diagnostic = resolvedType.diagnostic
source = constExpression.source
source = literalExpression.source
}
else -> constExpression
else -> literalExpression
}
}
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/contracts/ConeEffectExtractor.kt
+5 -5
View File
@@ -130,7 +130,7 @@ class ConeEffectExtractor(
}
val argument = equalityOperatorCall.arguments[1]
val const = argument as? FirConstExpression<*> ?: return ConeContractDescriptionError.NotAConstant(argument).asElement()
val const = argument as? FirLiteralExpression<*> ?: return ConeContractDescriptionError.NotAConstant(argument).asElement()
if (const.kind != ConstantValueKind.Null) return ConeContractDescriptionError.IllegalConst(const, onlyNullAllowed = true).asElement()
val arg = equalityOperatorCall.arguments[0].asContractValueExpression()
@@ -203,14 +203,14 @@ class ConeEffectExtractor(
}
}
override fun <T> visitConstExpression(constExpression: FirConstExpression<T>, data: Nothing?): ConeContractDescriptionElement {
return when (constExpression.kind) {
override fun <T> visitLiteralExpression(literalExpression: FirLiteralExpression<T>, data: Nothing?): ConeContractDescriptionElement {
return when (literalExpression.kind) {
ConstantValueKind.Null -> ConeContractConstantValues.NULL
ConstantValueKind.Boolean -> when (constExpression.value as Boolean) {
ConstantValueKind.Boolean -> when (literalExpression.value as Boolean) {
true -> ConeContractConstantValues.TRUE
false -> ConeContractConstantValues.FALSE
}
else -> ConeContractDescriptionError.IllegalConst(constExpression, onlyNullAllowed = false).asElement()
else -> ConeContractDescriptionError.IllegalConst(literalExpression, onlyNullAllowed = false).asElement()
}
}
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/mpp/FirExpectActualMatchingContextImpl.kt
+1 -1
View File
@@ -483,7 +483,7 @@ class FirExpectActualMatchingContextImpl private constructor(
// Because of that, we have "honest" checker at backend IR stage
// and "only simplest case" checker in frontend, so that we have at least some reporting in the IDE.
return when {
expression1 is FirConstExpression<*> && expression2 is FirConstExpression<*> -> {
expression1 is FirLiteralExpression<*> && expression2 is FirLiteralExpression<*> -> {
expression1.value == expression2.value
}
else -> true
compiler/fir/semantics/src/org/jetbrains/kotlin/fir/resolve/dfa/cfg/CFGNode.kt
+1 -1
View File
@@ -668,7 +668,7 @@ class JumpNode(owner: ControlFlowGraph, override val fir: FirJump<*>, level: Int
return visitor.visitJumpNode(this, data)
}
}
class ConstExpressionNode(owner: ControlFlowGraph, override val fir: FirConstExpression<*>, level: Int) : CFGNode<FirConstExpression<*>>(owner, level) {
class ConstExpressionNode(owner: ControlFlowGraph, override val fir: FirLiteralExpression<*>, level: Int) : CFGNode<FirLiteralExpression<*>>(owner, level) {
override fun <R, D> accept(visitor: ControlFlowGraphVisitor<R, D>, data: D): R {
return visitor.visitConstExpressionNode(this, data)
}
compiler/fir/semantics/src/org/jetbrains/kotlin/fir/resolve/diagnostics/ConeDiagnostics.kt
+2 -2
View File
@@ -13,7 +13,7 @@ import org.jetbrains.kotlin.fir.declarations.FirVariable
import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnostic
import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnosticWithNullability
import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnosticWithSource
import org.jetbrains.kotlin.fir.expressions.FirConstExpression
import org.jetbrains.kotlin.fir.expressions.FirLiteralExpression
import org.jetbrains.kotlin.fir.expressions.FirOperation
import org.jetbrains.kotlin.fir.expressions.FirThisReceiverExpression
import org.jetbrains.kotlin.fir.render
@@ -199,7 +199,7 @@ sealed class ConeContractDescriptionError : ConeDiagnostic {
}
class IllegalConst(
val element: FirConstExpression<*>,
val element: FirLiteralExpression<*>,
val onlyNullAllowed: Boolean
) : ConeContractDescriptionError() {
override val reason: String
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/FirConstExpression.kt → compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/FirLiteralExpression.kt
+5 -5
View File
@@ -16,9 +16,9 @@ import org.jetbrains.kotlin.fir.visitors.FirVisitor
import org.jetbrains.kotlin.types.ConstantValueKind
/**
* Generated from: [org.jetbrains.kotlin.fir.tree.generator.FirTreeBuilder.constExpression]
* Generated from: [org.jetbrains.kotlin.fir.tree.generator.FirTreeBuilder.literalExpression]
*/
abstract class FirConstExpression<T> : FirExpression() {
abstract class FirLiteralExpression<T> : FirExpression() {
abstract override val source: KtSourceElement?
@UnresolvedExpressionTypeAccess
abstract override val coneTypeOrNull: ConeKotlinType?
@@ -27,11 +27,11 @@ abstract class FirConstExpression<T> : FirExpression() {
abstract val value: T
override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
visitor.visitConstExpression(this, data)
visitor.visitLiteralExpression(this, data)
@Suppress("UNCHECKED_CAST")
override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
transformer.transformConstExpression(this, data) as E
transformer.transformLiteralExpression(this, data) as E
abstract override fun replaceConeTypeOrNull(newConeTypeOrNull: ConeKotlinType?)
@@ -39,5 +39,5 @@ abstract class FirConstExpression<T> : FirExpression() {
abstract fun replaceKind(newKind: ConstantValueKind<T>)
abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirConstExpression<T>
abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirLiteralExpression<T>
}
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/impl/FirConstExpressionImpl.kt → compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/impl/FirLiteralExpressionImpl.kt
+5 -5
View File
@@ -14,7 +14,7 @@ import org.jetbrains.kotlin.KtSourceElement
import org.jetbrains.kotlin.fir.MutableOrEmptyList
import org.jetbrains.kotlin.fir.builder.toMutableOrEmpty
import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.expressions.FirConstExpression
import org.jetbrains.kotlin.fir.expressions.FirLiteralExpression
import org.jetbrains.kotlin.fir.expressions.UnresolvedExpressionTypeAccess
import org.jetbrains.kotlin.fir.types.ConeKotlinType
import org.jetbrains.kotlin.fir.visitors.FirTransformer
@@ -23,25 +23,25 @@ import org.jetbrains.kotlin.fir.visitors.transformInplace
import org.jetbrains.kotlin.types.ConstantValueKind
@OptIn(UnresolvedExpressionTypeAccess::class)
internal class FirConstExpressionImpl<T> (
internal class FirLiteralExpressionImpl<T> (
override val source: KtSourceElement?,
@property:UnresolvedExpressionTypeAccess
override var coneTypeOrNull: ConeKotlinType?,
override var annotations: MutableOrEmptyList<FirAnnotation>,
override var kind: ConstantValueKind<T>,
override val value: T,
) : FirConstExpression<T>() {
) : FirLiteralExpression<T>() {
override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
annotations.forEach { it.accept(visitor, data) }
}
override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirConstExpressionImpl<T> {
override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirLiteralExpressionImpl<T> {
transformAnnotations(transformer, data)
return this
}
override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirConstExpressionImpl<T> {
override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirLiteralExpressionImpl<T> {
annotations.transformInplace(transformer, data)
return this
}
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirDefaultVisitor.kt
+2 -2
View File
@@ -101,8 +101,8 @@ abstract class FirDefaultVisitor<out R, in D> : FirVisitor<R, D>() {
override fun visitContinueExpression(continueExpression: FirContinueExpression, data: D): R =
visitLoopJump(continueExpression, data)
override fun <T> visitConstExpression(constExpression: FirConstExpression<T>, data: D): R =
visitExpression(constExpression, data)
override fun <T> visitLiteralExpression(literalExpression: FirLiteralExpression<T>, data: D): R =
visitExpression(literalExpression, data)
override fun visitStarProjection(starProjection: FirStarProjection, data: D): R =
visitTypeProjection(starProjection, data)
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirDefaultVisitorVoid.kt
+1 -1
View File
@@ -74,7 +74,7 @@ abstract class FirDefaultVisitorVoid : FirVisitorVoid() {
override fun visitContinueExpression(continueExpression: FirContinueExpression) = visitLoopJump(continueExpression)
override fun <T> visitConstExpression(constExpression: FirConstExpression<T>) = visitExpression(constExpression)
override fun <T> visitLiteralExpression(literalExpression: FirLiteralExpression<T>) = visitExpression(literalExpression)
override fun visitStarProjection(starProjection: FirStarProjection) = visitTypeProjection(starProjection)
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirTransformer.kt
+4 -4
View File
@@ -555,12 +555,12 @@ abstract class FirTransformer<in D> : FirVisitor<FirElement, D>() {
return transformTryExpression(tryExpression, data)
}
open fun <T> transformConstExpression(constExpression: FirConstExpression<T>, data: D): FirStatement {
return transformElement(constExpression, data)
open fun <T> transformLiteralExpression(literalExpression: FirLiteralExpression<T>, data: D): FirStatement {
return transformElement(literalExpression, data)
}
final override fun <T> visitConstExpression(constExpression: FirConstExpression<T>, data: D): FirStatement {
return transformConstExpression(constExpression, data)
final override fun <T> visitLiteralExpression(literalExpression: FirLiteralExpression<T>, data: D): FirStatement {
return transformLiteralExpression(literalExpression, data)
}
open fun transformTypeProjection(typeProjection: FirTypeProjection, data: D): FirTypeProjection {
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirVisitor.kt
+2 -2
View File
@@ -221,8 +221,8 @@ abstract class FirVisitor<out R, in D> {
open fun visitTryExpression(tryExpression: FirTryExpression, data: D): R =
visitElement(tryExpression, data)
open fun <T> visitConstExpression(constExpression: FirConstExpression<T>, data: D): R =
visitElement(constExpression, data)
open fun <T> visitLiteralExpression(literalExpression: FirLiteralExpression<T>, data: D): R =
visitElement(literalExpression, data)
open fun visitTypeProjection(typeProjection: FirTypeProjection, data: D): R =
visitElement(typeProjection, data)
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirVisitorVoid.kt
+4 -4
View File
@@ -555,12 +555,12 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
visitElement(tryExpression)
}
final override fun <T> visitConstExpression(constExpression: FirConstExpression<T>, data: Nothing?) {
visitConstExpression(constExpression)
final override fun <T> visitLiteralExpression(literalExpression: FirLiteralExpression<T>, data: Nothing?) {
visitLiteralExpression(literalExpression)
}
open fun <T> visitConstExpression(constExpression: FirConstExpression<T>) {
visitElement(constExpression)
open fun <T> visitLiteralExpression(literalExpression: FirLiteralExpression<T>) {
visitElement(literalExpression)
}
final override fun visitTypeProjection(typeProjection: FirTypeProjection, data: Nothing?) {
compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirExpressionUtil.kt
+2 -2
View File
@@ -11,7 +11,7 @@ import org.jetbrains.kotlin.fir.declarations.FirDeclarationOrigin
import org.jetbrains.kotlin.fir.declarations.FirValueParameter
import org.jetbrains.kotlin.fir.declarations.utils.isStatic
import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnostic
import org.jetbrains.kotlin.fir.expressions.builder.buildConstExpression
import org.jetbrains.kotlin.fir.expressions.builder.buildLiteralExpression
import org.jetbrains.kotlin.fir.expressions.builder.buildErrorExpression
import org.jetbrains.kotlin.fir.expressions.builder.buildErrorLoop
import org.jetbrains.kotlin.fir.expressions.impl.FirBlockImpl
@@ -34,7 +34,7 @@ inline val FirAnnotation.unexpandedClassId: ClassId?
fun <T> buildConstOrErrorExpression(source: KtSourceElement?, kind: ConstantValueKind<T>, value: T?, diagnostic: ConeDiagnostic): FirExpression =
value?.let {
buildConstExpression(source, kind, it, setType = false)
buildLiteralExpression(source, kind, it, setType = false)
} ?: buildErrorExpression {
this.source = source
this.diagnostic = diagnostic
compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/builder/FirConstExpressionBuilder.kt
+5 -5
View File
@@ -8,22 +8,22 @@ package org.jetbrains.kotlin.fir.expressions.builder
import org.jetbrains.kotlin.KtSourceElement
import org.jetbrains.kotlin.fir.builder.toMutableOrEmpty
import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.expressions.FirConstExpression
import org.jetbrains.kotlin.fir.expressions.FirLiteralExpression
import org.jetbrains.kotlin.fir.expressions.UnresolvedExpressionTypeAccess
import org.jetbrains.kotlin.fir.expressions.impl.FirConstExpressionImpl
import org.jetbrains.kotlin.fir.expressions.impl.FirLiteralExpressionImpl
import org.jetbrains.kotlin.fir.types.constructClassLikeType
import org.jetbrains.kotlin.name.StandardClassIds
import org.jetbrains.kotlin.types.ConstantValueKind
@OptIn(UnresolvedExpressionTypeAccess::class)
fun <T> buildConstExpression(
fun <T> buildLiteralExpression(
source: KtSourceElement?,
kind: ConstantValueKind<T>,
value: T,
annotations: MutableList<FirAnnotation> = mutableListOf(),
setType: Boolean
): FirConstExpression<T> {
return FirConstExpressionImpl(source, null, annotations.toMutableOrEmpty(), kind, value).also {
): FirLiteralExpression<T> {
return FirLiteralExpressionImpl(source, null, annotations.toMutableOrEmpty(), kind, value).also {
if (setType) {
when (kind) {
ConstantValueKind.Boolean -> it.coneTypeOrNull = StandardClassIds.Boolean.constructClassLikeType()
compiler/fir/tree/src/org/jetbrains/kotlin/fir/renderer/FirRenderer.kt
+4 -4
View File
@@ -699,10 +699,10 @@ class FirRenderer(
print("LAZY_EXPRESSION")
}
override fun <T> visitConstExpression(constExpression: FirConstExpression<T>) {
annotationRenderer?.render(constExpression)
val kind = constExpression.kind
val value = constExpression.value
override fun <T> visitLiteralExpression(literalExpression: FirLiteralExpression<T>) {
annotationRenderer?.render(literalExpression)
val kind = literalExpression.kind
val value = literalExpression.value
print("$kind(")
if (value !is Char) {
print(value.toString())
compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirTypeUtils.kt
+1 -1
View File
@@ -85,7 +85,7 @@ val FirTypeRef.isArrayType: Boolean
|| StandardClassIds.unsignedArrayTypeByElementType.values.any { isBuiltinType(it, false) }
val FirExpression.isNullLiteral: Boolean
get() = this is FirConstExpression<*> &&
get() = this is FirLiteralExpression<*> &&
this.kind == ConstantValueKind.Null &&
this.value == null &&
this.source != null

Some files were not shown because too many files have changed in this diff Show More