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

FIR tree refactoring: move FirElement.session to FirDeclaration

Browse Source 
#KT-30275 Fixed
This commit is contained in:
Mikhail Glukhikh
2019-07-20 15:47:42 +03:00
parent 98f75669a5
commit a38b4756b5
159 changed files with 502 additions and 932 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrVisitor.kt
+4 -4
View File
@@ -73,13 +73,13 @@ internal class Fir2IrVisitor(
private val declarationStorage = Fir2IrDeclarationStorage(session, symbolTable, moduleDescriptor) private val declarationStorage = Fir2IrDeclarationStorage(session, symbolTable, moduleDescriptor)
private val nothingType = FirImplicitNothingTypeRef(session, null).toIrType(session, declarationStorage) private val nothingType = FirImplicitNothingTypeRef(null).toIrType(session, declarationStorage)
private val unitType = FirImplicitUnitTypeRef(session, null).toIrType(session, declarationStorage) private val unitType = FirImplicitUnitTypeRef(null).toIrType(session, declarationStorage)
private val booleanType = FirImplicitBooleanTypeRef(session, null).toIrType(session, declarationStorage) private val booleanType = FirImplicitBooleanTypeRef(null).toIrType(session, declarationStorage)
private val stringType = FirImplicitStringTypeRef(session, null).toIrType(session, declarationStorage) private val stringType = FirImplicitStringTypeRef(null).toIrType(session, declarationStorage)
private fun ModuleDescriptor.findPackageFragmentForFile(file: FirFile): PackageFragmentDescriptor = private fun ModuleDescriptor.findPackageFragmentForFile(file: FirFile): PackageFragmentDescriptor =
getPackage(file.packageFqName).fragments.first() getPackage(file.packageFqName).fragments.first()
compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaSymbolProvider.kt
+1 -1
View File
@@ -219,7 +219,7 @@ class JavaSymbolProvider(
val firJavaConstructor = FirJavaConstructor( val firJavaConstructor = FirJavaConstructor(
this@JavaSymbolProvider.session, constructorSymbol, visibility, isPrimary, this@JavaSymbolProvider.session, constructorSymbol, visibility, isPrimary,
FirResolvedTypeRefImpl( FirResolvedTypeRefImpl(
this@JavaSymbolProvider.session, null, null,
firSymbol.constructType( firSymbol.constructType(
classTypeParameters.map { ConeTypeParameterTypeImpl(it.symbol.toLookupTag(), false) }.toTypedArray(), classTypeParameters.map { ConeTypeParameterTypeImpl(it.symbol.toLookupTag(), false) }.toTypedArray(),
false false
compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaUtils.kt
+24 -25
View File
@@ -81,8 +81,8 @@ internal fun JavaType?.toNotNullConeKotlinType(
internal fun JavaType.toFirJavaTypeRef(session: FirSession, javaTypeParameterStack: JavaTypeParameterStack): FirJavaTypeRef { internal fun JavaType.toFirJavaTypeRef(session: FirSession, javaTypeParameterStack: JavaTypeParameterStack): FirJavaTypeRef {
val annotations = (this as? JavaClassifierType)?.annotations.orEmpty() val annotations = (this as? JavaClassifierType)?.annotations.orEmpty()
return FirJavaTypeRef( return FirJavaTypeRef(
session, annotations = annotations.map { it.toFirAnnotationCall(session, javaTypeParameterStack) },
annotations = annotations.map { it.toFirAnnotationCall(session, javaTypeParameterStack) }, type = this type = this
) )
} }
@@ -91,7 +91,7 @@ internal fun JavaClassifierType.toFirResolvedTypeRef(
): FirResolvedTypeRef { ): FirResolvedTypeRef {
val coneType = this.toConeKotlinTypeWithNullability(session, javaTypeParameterStack, isNullable = false) val coneType = this.toConeKotlinTypeWithNullability(session, javaTypeParameterStack, isNullable = false)
return FirResolvedTypeRefImpl( return FirResolvedTypeRefImpl(
session, psi = null, type = coneType, psi = null, type = coneType,
annotations = annotations.map { it.toFirAnnotationCall(session, javaTypeParameterStack) } annotations = annotations.map { it.toFirAnnotationCall(session, javaTypeParameterStack) }
) )
} }
@@ -170,9 +170,8 @@ internal fun JavaAnnotation.toFirAnnotationCall(
session: FirSession, javaTypeParameterStack: JavaTypeParameterStack session: FirSession, javaTypeParameterStack: JavaTypeParameterStack
): FirAnnotationCall { ): FirAnnotationCall {
return FirAnnotationCallImpl( return FirAnnotationCallImpl(
session, psi = null, useSiteTarget = null, psi = null, useSiteTarget = null,
annotationTypeRef = FirResolvedTypeRefImpl( annotationTypeRef = FirResolvedTypeRefImpl(
session,
psi = null, psi = null,
type = ConeClassTypeImpl(FirClassSymbol(classId!!).toLookupTag(), emptyArray(), isNullable = false), type = ConeClassTypeImpl(FirClassSymbol(classId!!).toLookupTag(), emptyArray(), isNullable = false),
annotations = emptyList() annotations = emptyList()
@@ -237,13 +236,13 @@ private fun JavaAnnotationArgument.toFirExpression(
is JavaLiteralAnnotationArgument -> { is JavaLiteralAnnotationArgument -> {
value.createConstant(session) value.createConstant(session)
} }
is JavaArrayAnnotationArgument -> FirArrayOfCallImpl(session, null).apply { is JavaArrayAnnotationArgument -> FirArrayOfCallImpl(null).apply {
for (element in getElements()) { for (element in getElements()) {
arguments += element.toFirExpression(session, javaTypeParameterStack) arguments += element.toFirExpression(session, javaTypeParameterStack)
} }
} }
is JavaEnumValueAnnotationArgument -> { is JavaEnumValueAnnotationArgument -> {
FirFunctionCallImpl(session, null).apply { FirFunctionCallImpl(null).apply {
val classId = this@toFirExpression.enumClassId val classId = this@toFirExpression.enumClassId
val entryName = this@toFirExpression.entryName val entryName = this@toFirExpression.entryName
val calleeReference = if (classId != null && entryName != null) { val calleeReference = if (classId != null && entryName != null) {
@@ -251,29 +250,29 @@ private fun JavaAnnotationArgument.toFirExpression(
classId, entryName classId, entryName
).firstOrNull() ).firstOrNull()
callableSymbol?.let { callableSymbol?.let {
FirResolvedCallableReferenceImpl(session, null, entryName, it) FirResolvedCallableReferenceImpl(null, entryName, it)
} }
} else { } else {
null null
} }
this.calleeReference = calleeReference this.calleeReference = calleeReference
?: FirErrorNamedReference(session, null, "Strange Java enum value: $classId.$entryName") ?: FirErrorNamedReference(null, "Strange Java enum value: $classId.$entryName")
} }
} }
is JavaClassObjectAnnotationArgument -> FirGetClassCallImpl(session, null).apply { is JavaClassObjectAnnotationArgument -> FirGetClassCallImpl(null).apply {
val referencedType = getReferencedType() val referencedType = getReferencedType()
arguments += FirClassReferenceExpressionImpl( arguments += FirClassReferenceExpressionImpl(
session, null, referencedType.toFirResolvedTypeRef(session, javaTypeParameterStack) null, referencedType.toFirResolvedTypeRef(session, javaTypeParameterStack)
) )
} }
is JavaAnnotationAsAnnotationArgument -> getAnnotation().toFirAnnotationCall(session, javaTypeParameterStack) is JavaAnnotationAsAnnotationArgument -> getAnnotation().toFirAnnotationCall(session, javaTypeParameterStack)
else -> FirErrorExpressionImpl(session, null, "Unknown JavaAnnotationArgument: ${this::class.java}") else -> FirErrorExpressionImpl(null, "Unknown JavaAnnotationArgument: ${this::class.java}")
} }
} }
// TODO: use kind here // TODO: use kind here
private fun <T> List<T>.createArrayOfCall(session: FirSession, @Suppress("UNUSED_PARAMETER") kind: IrConstKind<T>): FirArrayOfCall { private fun <T> List<T>.createArrayOfCall(session: FirSession, @Suppress("UNUSED_PARAMETER") kind: IrConstKind<T>): FirArrayOfCall {
return FirArrayOfCallImpl(session, null).apply { return FirArrayOfCallImpl(null).apply {
for (element in this@createArrayOfCall) { for (element in this@createArrayOfCall) {
arguments += element.createConstant(session) arguments += element.createConstant(session)
} }
@@ -282,15 +281,15 @@ private fun <T> List<T>.createArrayOfCall(session: FirSession, @Suppress("UNUSED
internal fun Any?.createConstant(session: FirSession): FirExpression { internal fun Any?.createConstant(session: FirSession): FirExpression {
return when (this) { return when (this) {
is Byte -> FirConstExpressionImpl(session, null, IrConstKind.Byte, this) is Byte -> FirConstExpressionImpl(null, IrConstKind.Byte, this)
is Short -> FirConstExpressionImpl(session, null, IrConstKind.Short, this) is Short -> FirConstExpressionImpl(null, IrConstKind.Short, this)
is Int -> FirConstExpressionImpl(session, null, IrConstKind.Int, this) is Int -> FirConstExpressionImpl(null, IrConstKind.Int, this)
is Long -> FirConstExpressionImpl(session, null, IrConstKind.Long, this) is Long -> FirConstExpressionImpl(null, IrConstKind.Long, this)
is Char -> FirConstExpressionImpl(session, null, IrConstKind.Char, this) is Char -> FirConstExpressionImpl(null, IrConstKind.Char, this)
is Float -> FirConstExpressionImpl(session, null, IrConstKind.Float, this) is Float -> FirConstExpressionImpl(null, IrConstKind.Float, this)
is Double -> FirConstExpressionImpl(session, null, IrConstKind.Double, this) is Double -> FirConstExpressionImpl(null, IrConstKind.Double, this)
is Boolean -> FirConstExpressionImpl(session, null, IrConstKind.Boolean, this) is Boolean -> FirConstExpressionImpl(null, IrConstKind.Boolean, this)
is String -> FirConstExpressionImpl(session, null, IrConstKind.String, this) is String -> FirConstExpressionImpl(null, IrConstKind.String, this)
is ByteArray -> toList().createArrayOfCall(session, IrConstKind.Byte) is ByteArray -> toList().createArrayOfCall(session, IrConstKind.Byte)
is ShortArray -> toList().createArrayOfCall(session, IrConstKind.Short) is ShortArray -> toList().createArrayOfCall(session, IrConstKind.Short)
is IntArray -> toList().createArrayOfCall(session, IrConstKind.Int) is IntArray -> toList().createArrayOfCall(session, IrConstKind.Int)
@@ -299,9 +298,9 @@ internal fun Any?.createConstant(session: FirSession): FirExpression {
is FloatArray -> toList().createArrayOfCall(session, IrConstKind.Float) is FloatArray -> toList().createArrayOfCall(session, IrConstKind.Float)
is DoubleArray -> toList().createArrayOfCall(session, IrConstKind.Double) is DoubleArray -> toList().createArrayOfCall(session, IrConstKind.Double)
is BooleanArray -> toList().createArrayOfCall(session, IrConstKind.Boolean) is BooleanArray -> toList().createArrayOfCall(session, IrConstKind.Boolean)
null -> FirConstExpressionImpl(session, null, IrConstKind.Null, null) null -> FirConstExpressionImpl(null, IrConstKind.Null, null)
else -> FirErrorExpressionImpl(session, null, "Unknown value in JavaLiteralAnnotationArgument: $this") else -> FirErrorExpressionImpl(null, "Unknown value in JavaLiteralAnnotationArgument: $this")
} }
} }
@@ -310,7 +309,7 @@ private fun JavaType.toFirResolvedTypeRef(
): FirResolvedTypeRef { ): FirResolvedTypeRef {
if (this is JavaClassifierType) return toFirResolvedTypeRef(session, javaTypeParameterStack) if (this is JavaClassifierType) return toFirResolvedTypeRef(session, javaTypeParameterStack)
return FirResolvedTypeRefImpl( return FirResolvedTypeRefImpl(
session, psi = null, type = ConeClassErrorType("Unexpected JavaType: $this"), psi = null, type = ConeClassErrorType("Unexpected JavaType: $this"),
annotations = emptyList() annotations = emptyList()
) )
} }
compiler/fir/java/src/org/jetbrains/kotlin/fir/java/deserialization/KotlinDeserializedJvmSymbolsProvider.kt
+11 -11
View File
@@ -176,10 +176,10 @@ class KotlinDeserializedJvmSymbolsProvider(
private fun ConeClassifierSymbol?.toDefaultResolvedTypeRef(classId: ClassId): FirResolvedTypeRef { private fun ConeClassifierSymbol?.toDefaultResolvedTypeRef(classId: ClassId): FirResolvedTypeRef {
return this?.let { return this?.let {
FirResolvedTypeRefImpl( FirResolvedTypeRefImpl(
session, null, it.constructType(emptyList(), isNullable = false), null, it.constructType(emptyList(), isNullable = false),
annotations = emptyList() annotations = emptyList()
) )
} ?: FirErrorTypeRefImpl(session, null, "Symbol not found for $classId") } ?: FirErrorTypeRefImpl(null, "Symbol not found for $classId")
} }
@@ -202,13 +202,13 @@ class KotlinDeserializedJvmSymbolsProvider(
val literalLookupTag = ConeClassLikeLookupTagImpl(classId) val literalLookupTag = ConeClassLikeLookupTagImpl(classId)
val literalSymbol = literalLookupTag.toSymbol(this@KotlinDeserializedJvmSymbolsProvider.session) val literalSymbol = literalLookupTag.toSymbol(this@KotlinDeserializedJvmSymbolsProvider.session)
return FirClassReferenceExpressionImpl( return FirClassReferenceExpressionImpl(
this@KotlinDeserializedJvmSymbolsProvider.session, null, null,
literalSymbol.toDefaultResolvedTypeRef(classId) literalSymbol.toDefaultResolvedTypeRef(classId)
) )
} }
private fun ClassId.toEnumEntryReferenceExpression(name: Name): FirExpression { private fun ClassId.toEnumEntryReferenceExpression(name: Name): FirExpression {
return FirFunctionCallImpl(session, null).apply { return FirFunctionCallImpl(null).apply {
val entryClassId = createNestedClassId(name) val entryClassId = createNestedClassId(name)
val entryLookupTag = ConeClassLikeLookupTagImpl(entryClassId) val entryLookupTag = ConeClassLikeLookupTagImpl(entryClassId)
val entryClassSymbol = entryLookupTag.toSymbol(this@KotlinDeserializedJvmSymbolsProvider.session) val entryClassSymbol = entryLookupTag.toSymbol(this@KotlinDeserializedJvmSymbolsProvider.session)
@@ -220,17 +220,17 @@ class KotlinDeserializedJvmSymbolsProvider(
this.calleeReference = when { this.calleeReference = when {
entryClassSymbol != null && (entryClassSymbol as? FirClassSymbol)?.fir is FirEnumEntry -> { entryClassSymbol != null && (entryClassSymbol as? FirClassSymbol)?.fir is FirEnumEntry -> {
FirResolvedCallableReferenceImpl( FirResolvedCallableReferenceImpl(
this@KotlinDeserializedJvmSymbolsProvider.session, null, name, entryClassSymbol null, name, entryClassSymbol
) )
} }
entryCallableSymbol != null -> { entryCallableSymbol != null -> {
FirResolvedCallableReferenceImpl( FirResolvedCallableReferenceImpl(
this@KotlinDeserializedJvmSymbolsProvider.session, null, name, entryCallableSymbol null, name, entryCallableSymbol
) )
} }
else -> { else -> {
FirErrorNamedReference( FirErrorNamedReference(
this@KotlinDeserializedJvmSymbolsProvider.session, null, null,
errorReason = "Strange deserialized enum value: ${this@toEnumEntryReferenceExpression}.$name" errorReason = "Strange deserialized enum value: ${this@toEnumEntryReferenceExpression}.$name"
) )
} }
@@ -239,7 +239,7 @@ class KotlinDeserializedJvmSymbolsProvider(
} }
override fun visitClassLiteral(name: Name, value: ClassLiteralValue) { override fun visitClassLiteral(name: Name, value: ClassLiteralValue) {
argumentMap[name] = FirGetClassCallImpl(session, null).apply { argumentMap[name] = FirGetClassCallImpl(null).apply {
arguments += value.toFirClassReferenceExpression() arguments += value.toFirClassReferenceExpression()
} }
} }
@@ -265,7 +265,7 @@ class KotlinDeserializedJvmSymbolsProvider(
} }
override fun visitEnd() { override fun visitEnd() {
argumentMap[name] = FirArrayOfCallImpl(session, null).apply { argumentMap[name] = FirArrayOfCallImpl(null).apply {
arguments += elements arguments += elements
} }
} }
@@ -284,10 +284,10 @@ class KotlinDeserializedJvmSymbolsProvider(
} }
override fun visitEnd() { override fun visitEnd() {
result += FirAnnotationCallImpl(session, null, null, symbol.toDefaultResolvedTypeRef(annotationClassId)).apply { result += FirAnnotationCallImpl(null, null, symbol.toDefaultResolvedTypeRef(annotationClassId)).apply {
for ((name, expression) in argumentMap) { for ((name, expression) in argumentMap) {
arguments += FirNamedArgumentExpressionImpl( arguments += FirNamedArgumentExpressionImpl(
this@KotlinDeserializedJvmSymbolsProvider.session, null, name, false, expression null, name, false, expression
) )
} }
} }
compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/javaTypeUtils.kt
+15 -15
View File
@@ -82,14 +82,14 @@ private fun JavaType?.enhancePossiblyFlexible(
) )
FirResolvedTypeRefImpl( FirResolvedTypeRefImpl(
session, psi = null, psi = null,
type = coneFlexibleOrSimpleType(session, lowerResult, upperResult), type = coneFlexibleOrSimpleType(session, lowerResult, upperResult),
annotations = annotations annotations = annotations
) )
} }
else -> { else -> {
val enhanced = type.toNotNullConeKotlinType(session, javaTypeParameterStack) val enhanced = type.toNotNullConeKotlinType(session, javaTypeParameterStack)
FirResolvedTypeRefImpl(session, psi = null, type = enhanced, annotations = annotations) FirResolvedTypeRefImpl(psi = null, type = enhanced, annotations = annotations)
} }
} }
} }
@@ -245,18 +245,18 @@ internal fun ConeKotlinType.lexicalCastFrom(session: FirSession, value: String):
val name = Name.identifier(value) val name = Name.identifier(value)
val firEnumEntry = firElement.declarations.filterIsInstance<FirEnumEntry>().find { it.name == name } val firEnumEntry = firElement.declarations.filterIsInstance<FirEnumEntry>().find { it.name == name }
return if (firEnumEntry != null) FirQualifiedAccessExpressionImpl(session, null).apply { return if (firEnumEntry != null) FirQualifiedAccessExpressionImpl(null).apply {
calleeReference = FirSimpleNamedReference( calleeReference = FirSimpleNamedReference(
session, null, name // TODO: , firEnumEntry.symbol null, name // TODO: , firEnumEntry.symbol
) )
} else if (firElement is FirJavaClass) { } else if (firElement is FirJavaClass) {
val firStaticProperty = firElement.declarations.filterIsInstance<FirJavaField>().find { val firStaticProperty = firElement.declarations.filterIsInstance<FirJavaField>().find {
it.isStatic && it.modality == Modality.FINAL && it.name == name it.isStatic && it.modality == Modality.FINAL && it.name == name
} }
if (firStaticProperty != null) { if (firStaticProperty != null) {
FirQualifiedAccessExpressionImpl(session, null).apply { FirQualifiedAccessExpressionImpl(null).apply {
calleeReference = FirResolvedCallableReferenceImpl( calleeReference = FirResolvedCallableReferenceImpl(
session, null, name, firStaticProperty.symbol as ConeCallableSymbol null, name, firStaticProperty.symbol as ConeCallableSymbol
) )
} }
} else null } else null
@@ -269,15 +269,15 @@ internal fun ConeKotlinType.lexicalCastFrom(session: FirSession, value: String):
val (number, radix) = extractRadix(value) val (number, radix) = extractRadix(value)
return when (classId.relativeClassName.asString()) { return when (classId.relativeClassName.asString()) {
"Boolean" -> FirConstExpressionImpl(session, null, IrConstKind.Boolean, value.toBoolean()) "Boolean" -> FirConstExpressionImpl(null, IrConstKind.Boolean, value.toBoolean())
"Char" -> FirConstExpressionImpl(session, null, IrConstKind.Char, value.singleOrNull() ?: return null) "Char" -> FirConstExpressionImpl(null, IrConstKind.Char, value.singleOrNull() ?: return null)
"Byte" -> FirConstExpressionImpl(session, null, IrConstKind.Byte, number.toByteOrNull(radix) ?: return null) "Byte" -> FirConstExpressionImpl(null, IrConstKind.Byte, number.toByteOrNull(radix) ?: return null)
"Short" -> FirConstExpressionImpl(session, null, IrConstKind.Short, number.toShortOrNull(radix) ?: return null) "Short" -> FirConstExpressionImpl(null, IrConstKind.Short, number.toShortOrNull(radix) ?: return null)
"Int" -> FirConstExpressionImpl(session, null, IrConstKind.Int, number.toIntOrNull(radix) ?: return null) "Int" -> FirConstExpressionImpl(null, IrConstKind.Int, number.toIntOrNull(radix) ?: return null)
"Long" -> FirConstExpressionImpl(session, null, IrConstKind.Long, number.toLongOrNull(radix) ?: return null) "Long" -> FirConstExpressionImpl(null, IrConstKind.Long, number.toLongOrNull(radix) ?: return null)
"Float" -> FirConstExpressionImpl(session, null, IrConstKind.Float, value.toFloatOrNull() ?: return null) "Float" -> FirConstExpressionImpl(null, IrConstKind.Float, value.toFloatOrNull() ?: return null)
"Double" -> FirConstExpressionImpl(session, null, IrConstKind.Double, value.toDoubleOrNull() ?: return null) "Double" -> FirConstExpressionImpl(null, IrConstKind.Double, value.toDoubleOrNull() ?: return null)
"String" -> FirConstExpressionImpl(session, null, IrConstKind.String, value) "String" -> FirConstExpressionImpl(null, IrConstKind.String, value)
else -> null else -> null
} }
} }
compiler/fir/java/src/org/jetbrains/kotlin/fir/java/scopes/JavaClassEnhancementScope.kt
+1 -1
View File
@@ -302,7 +302,7 @@ class JavaClassEnhancementScope(
).enhance(session, jsr305State, predefinedEnhancementInfo?.parametersInfo?.getOrNull(index)) ).enhance(session, jsr305State, predefinedEnhancementInfo?.parametersInfo?.getOrNull(index))
val firResolvedTypeRef = signatureParts.type val firResolvedTypeRef = signatureParts.type
val defaultValueExpression = when (val defaultValue = ownerParameter.getDefaultValueFromAnnotation()) { val defaultValueExpression = when (val defaultValue = ownerParameter.getDefaultValueFromAnnotation()) {
NullDefaultValue -> FirConstExpressionImpl(session, null, IrConstKind.Null, null) NullDefaultValue -> FirConstExpressionImpl(null, IrConstKind.Null, null)
is StringDefaultValue -> firResolvedTypeRef.type.lexicalCastFrom(session, defaultValue.value) is StringDefaultValue -> firResolvedTypeRef.type.lexicalCastFrom(session, defaultValue.value)
null -> null null -> null
} }
compiler/fir/java/src/org/jetbrains/kotlin/fir/java/types/FirJavaTypeRef.kt
+1 -3
View File
@@ -5,16 +5,14 @@
package org.jetbrains.kotlin.fir.java.types package org.jetbrains.kotlin.fir.java.types
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
import org.jetbrains.kotlin.fir.types.impl.FirUserTypeRefImpl import org.jetbrains.kotlin.fir.types.impl.FirUserTypeRefImpl
import org.jetbrains.kotlin.load.java.structure.JavaType import org.jetbrains.kotlin.load.java.structure.JavaType
class FirJavaTypeRef( class FirJavaTypeRef(
session: FirSession,
annotations: List<FirAnnotationCall>, annotations: List<FirAnnotationCall>,
val type: JavaType val type: JavaType
) : FirUserTypeRefImpl(session, psi = null, isMarkedNullable = false) { ) : FirUserTypeRefImpl(psi = null, isMarkedNullable = false) {
init { init {
this.annotations += annotations this.annotations += annotations
} }
compiler/fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/ConversionUtils.kt
+96 -104
View File
@@ -102,7 +102,7 @@ internal fun translateEscape(c: Char): Char? =
else -> null else -> null
} }
internal fun generateConstantExpressionByLiteral(session: FirSession, expression: KtConstantExpression): FirExpression { internal fun generateConstantExpressionByLiteral(expression: KtConstantExpression): FirExpression {
val type = expression.node.elementType val type = expression.node.elementType
val text: String = expression.text val text: String = expression.text
val convertedText: Any? = when (type) { val convertedText: Any? = when (type) {
@@ -117,32 +117,32 @@ internal fun generateConstantExpressionByLiteral(session: FirSession, expression
convertedText > Int.MAX_VALUE || convertedText < Int.MIN_VALUE) convertedText > Int.MAX_VALUE || convertedText < Int.MIN_VALUE)
) { ) {
FirConstExpressionImpl( FirConstExpressionImpl(
session, expression, IrConstKind.Long, convertedText, "Incorrect long: $text" expression, IrConstKind.Long, convertedText, "Incorrect long: $text"
) )
} else if (convertedText is Number) { } else if (convertedText is Number) {
// TODO: support byte / short // TODO: support byte / short
FirConstExpressionImpl(session, expression, IrConstKind.Int, convertedText.toInt(), "Incorrect int: $text") FirConstExpressionImpl(expression, IrConstKind.Int, convertedText.toInt(), "Incorrect int: $text")
} else { } else {
FirErrorExpressionImpl(session, expression, reason = "Incorrect constant expression: $text") FirErrorExpressionImpl(expression, reason = "Incorrect constant expression: $text")
} }
KtNodeTypes.FLOAT_CONSTANT -> KtNodeTypes.FLOAT_CONSTANT ->
if (convertedText is Float) { if (convertedText is Float) {
FirConstExpressionImpl( FirConstExpressionImpl(
session, expression, IrConstKind.Float, convertedText, "Incorrect float: $text" expression, IrConstKind.Float, convertedText, "Incorrect float: $text"
) )
} else { } else {
FirConstExpressionImpl( FirConstExpressionImpl(
session, expression, IrConstKind.Double, convertedText as Double, "Incorrect double: $text" expression, IrConstKind.Double, convertedText as Double, "Incorrect double: $text"
) )
} }
KtNodeTypes.CHARACTER_CONSTANT -> KtNodeTypes.CHARACTER_CONSTANT ->
FirConstExpressionImpl( FirConstExpressionImpl(
session, expression, IrConstKind.Char, text.parseCharacter(), "Incorrect character: $text" expression, IrConstKind.Char, text.parseCharacter(), "Incorrect character: $text"
) )
KtNodeTypes.BOOLEAN_CONSTANT -> KtNodeTypes.BOOLEAN_CONSTANT ->
FirConstExpressionImpl(session, expression, IrConstKind.Boolean, convertedText as Boolean) FirConstExpressionImpl(expression, IrConstKind.Boolean, convertedText as Boolean)
KtNodeTypes.NULL -> KtNodeTypes.NULL ->
FirConstExpressionImpl(session, expression, IrConstKind.Null, null) FirConstExpressionImpl(expression, IrConstKind.Null, null)
else -> else ->
throw AssertionError("Unknown literal type: $type, $text") throw AssertionError("Unknown literal type: $type, $text")
} }
@@ -187,59 +187,56 @@ internal fun FirExpression.generateNotNullOrOther(
val subjectName = Name.special("<$caseId>") val subjectName = Name.special("<$caseId>")
val subjectVariable = generateTemporaryVariable(session, psi, subjectName, this) val subjectVariable = generateTemporaryVariable(session, psi, subjectName, this)
val subject = FirWhenSubject() val subject = FirWhenSubject()
val subjectExpression = FirWhenSubjectExpressionImpl(session, psi, subject) val subjectExpression = FirWhenSubjectExpressionImpl(psi, subject)
return FirWhenExpressionImpl( return FirWhenExpressionImpl(
session, basePsi, this, subjectVariable basePsi, this, subjectVariable
).apply { ).apply {
subject.bind(this) subject.bind(this)
branches += FirWhenBranchImpl( branches += FirWhenBranchImpl(
session, psi, psi,
FirOperatorCallImpl(session, psi, FirOperation.EQ).apply { FirOperatorCallImpl(psi, FirOperation.EQ).apply {
arguments += subjectExpression arguments += subjectExpression
arguments += FirConstExpressionImpl(session, psi, IrConstKind.Null, null) arguments += FirConstExpressionImpl(psi, IrConstKind.Null, null)
}, },
FirSingleExpressionBlock(session, other) FirSingleExpressionBlock(other)
) )
branches += FirWhenBranchImpl( branches += FirWhenBranchImpl(
session, other.psi, FirElseIfTrueCondition(session, psi), other.psi, FirElseIfTrueCondition(psi),
FirSingleExpressionBlock( FirSingleExpressionBlock(
session, FirUncheckedNotNullCastImpl(psi, generateResolvedAccessExpression(psi, subjectVariable))
FirUncheckedNotNullCastImpl(session, psi, generateResolvedAccessExpression(session, psi, subjectVariable))
) )
) )
} }
} }
internal fun FirExpression.generateLazyLogicalOperation( internal fun FirExpression.generateLazyLogicalOperation(
session: FirSession, other: FirExpression, isAnd: Boolean, basePsi: KtElement other: FirExpression, isAnd: Boolean, basePsi: KtElement
): FirWhenExpression { ): FirWhenExpression {
val terminalExpression = FirConstExpressionImpl(session, psi, IrConstKind.Boolean, !isAnd) val terminalExpression = FirConstExpressionImpl(psi, IrConstKind.Boolean, !isAnd)
val terminalBlock = FirSingleExpressionBlock(session, terminalExpression) val terminalBlock = FirSingleExpressionBlock(terminalExpression)
val otherBlock = FirSingleExpressionBlock(session, other) val otherBlock = FirSingleExpressionBlock(other)
return FirWhenExpressionImpl(session, basePsi).apply { return FirWhenExpressionImpl(basePsi).apply {
branches += FirWhenBranchImpl( branches += FirWhenBranchImpl(
session, psi, this@generateLazyLogicalOperation, psi, this@generateLazyLogicalOperation,
if (isAnd) otherBlock else terminalBlock if (isAnd) otherBlock else terminalBlock
) )
branches += FirWhenBranchImpl( branches += FirWhenBranchImpl(
session, other.psi, FirElseIfTrueCondition(session, psi), other.psi, FirElseIfTrueCondition(psi),
if (isAnd) terminalBlock else otherBlock if (isAnd) terminalBlock else otherBlock
) )
typeRef = FirImplicitBooleanTypeRef(session, basePsi) typeRef = FirImplicitBooleanTypeRef(basePsi)
} }
} }
internal fun KtWhenCondition.toFirWhenCondition( internal fun KtWhenCondition.toFirWhenCondition(
session: FirSession,
subject: FirWhenSubject, subject: FirWhenSubject,
convert: KtExpression?.(String) -> FirExpression, convert: KtExpression?.(String) -> FirExpression,
toFirOrErrorTypeRef: KtTypeReference?.() -> FirTypeRef toFirOrErrorTypeRef: KtTypeReference?.() -> FirTypeRef
): FirExpression { ): FirExpression {
val firSubjectExpression = FirWhenSubjectExpressionImpl(session, this, subject) val firSubjectExpression = FirWhenSubjectExpressionImpl(this, subject)
return when (this) { return when (this) {
is KtWhenConditionWithExpression -> { is KtWhenConditionWithExpression -> {
FirOperatorCallImpl( FirOperatorCallImpl(
session,
expression, expression,
FirOperation.EQ FirOperation.EQ
).apply { ).apply {
@@ -249,24 +246,23 @@ internal fun KtWhenCondition.toFirWhenCondition(
} }
is KtWhenConditionInRange -> { is KtWhenConditionInRange -> {
val firRange = rangeExpression.convert("No range in condition with range") val firRange = rangeExpression.convert("No range in condition with range")
firRange.generateContainsOperation(session, firSubjectExpression, isNegated, rangeExpression, operationReference) firRange.generateContainsOperation(firSubjectExpression, isNegated, rangeExpression, operationReference)
} }
is KtWhenConditionIsPattern -> { is KtWhenConditionIsPattern -> {
FirTypeOperatorCallImpl( FirTypeOperatorCallImpl(
session, typeReference, if (isNegated) FirOperation.NOT_IS else FirOperation.IS, typeReference, if (isNegated) FirOperation.NOT_IS else FirOperation.IS,
typeReference.toFirOrErrorTypeRef() typeReference.toFirOrErrorTypeRef()
).apply { ).apply {
arguments += firSubjectExpression arguments += firSubjectExpression
} }
} }
else -> { else -> {
FirErrorExpressionImpl(session, this, "Unsupported when condition: ${this.javaClass}") FirErrorExpressionImpl(this, "Unsupported when condition: ${this.javaClass}")
} }
} }
} }
internal fun Array<KtWhenCondition>.toFirWhenCondition( internal fun Array<KtWhenCondition>.toFirWhenCondition(
session: FirSession,
basePsi: KtElement, basePsi: KtElement,
subject: FirWhenSubject, subject: FirWhenSubject,
convert: KtExpression?.(String) -> FirExpression, convert: KtExpression?.(String) -> FirExpression,
@@ -274,11 +270,11 @@ internal fun Array<KtWhenCondition>.toFirWhenCondition(
): FirExpression { ): FirExpression {
var firCondition: FirExpression? = null var firCondition: FirExpression? = null
for (condition in this) { for (condition in this) {
val firConditionElement = condition.toFirWhenCondition(session, subject, convert, toFirOrErrorTypeRef) val firConditionElement = condition.toFirWhenCondition(subject, convert, toFirOrErrorTypeRef)
firCondition = when (firCondition) { firCondition = when (firCondition) {
null -> firConditionElement null -> firConditionElement
else -> firCondition.generateLazyLogicalOperation( else -> firCondition.generateLazyLogicalOperation(
session, firConditionElement, false, basePsi firConditionElement, false, basePsi
) )
} }
} }
@@ -286,7 +282,6 @@ internal fun Array<KtWhenCondition>.toFirWhenCondition(
} }
internal fun Array<KtStringTemplateEntry>.toInterpolatingCall( internal fun Array<KtStringTemplateEntry>.toInterpolatingCall(
session: FirSession,
base: KtStringTemplateExpression, base: KtStringTemplateExpression,
convert: KtExpression?.(String) -> FirExpression convert: KtExpression?.(String) -> FirExpression
): FirExpression { ): FirExpression {
@@ -298,11 +293,11 @@ internal fun Array<KtStringTemplateEntry>.toInterpolatingCall(
val nextArgument = when (entry) { val nextArgument = when (entry) {
is KtLiteralStringTemplateEntry -> { is KtLiteralStringTemplateEntry -> {
sb.append(entry.text) sb.append(entry.text)
FirConstExpressionImpl(session, entry, IrConstKind.String, entry.text) FirConstExpressionImpl(entry, IrConstKind.String, entry.text)
} }
is KtEscapeStringTemplateEntry -> { is KtEscapeStringTemplateEntry -> {
sb.append(entry.unescapedValue) sb.append(entry.unescapedValue)
FirConstExpressionImpl(session, entry, IrConstKind.String, entry.unescapedValue) FirConstExpressionImpl(entry, IrConstKind.String, entry.unescapedValue)
} }
is KtStringTemplateEntryWithExpression -> { is KtStringTemplateEntryWithExpression -> {
val innerExpression = entry.expression val innerExpression = entry.expression
@@ -312,7 +307,7 @@ internal fun Array<KtStringTemplateEntry>.toInterpolatingCall(
else -> { else -> {
hasExpressions = true hasExpressions = true
FirErrorExpressionImpl( FirErrorExpressionImpl(
session, entry, "Incorrect template entry: ${entry.text}" entry, "Incorrect template entry: ${entry.text}"
) )
} }
} }
@@ -323,31 +318,30 @@ internal fun Array<KtStringTemplateEntry>.toInterpolatingCall(
} }
else -> { else -> {
callCreated = true callCreated = true
FirStringConcatenationCallImpl(session, base).apply { FirStringConcatenationCallImpl(base).apply {
arguments += result!! arguments += result!!
arguments += nextArgument arguments += nextArgument
} }
} }
} }
} }
return if (hasExpressions) result!! else FirConstExpressionImpl(session, base, IrConstKind.String, sb.toString()) return if (hasExpressions) result!! else FirConstExpressionImpl(base, IrConstKind.String, sb.toString())
} }
internal fun FirExpression.generateContainsOperation( internal fun FirExpression.generateContainsOperation(
session: FirSession,
argument: FirExpression, argument: FirExpression,
inverted: Boolean, inverted: Boolean,
base: KtExpression?, base: KtExpression?,
operationReference: KtOperationReferenceExpression operationReference: KtOperationReferenceExpression
): FirFunctionCall { ): FirFunctionCall {
val containsCall = FirFunctionCallImpl(session, base).apply { val containsCall = FirFunctionCallImpl(base).apply {
calleeReference = FirSimpleNamedReference(session, operationReference, OperatorNameConventions.CONTAINS) calleeReference = FirSimpleNamedReference(operationReference, OperatorNameConventions.CONTAINS)
explicitReceiver = this@generateContainsOperation explicitReceiver = this@generateContainsOperation
arguments += argument arguments += argument
} }
if (!inverted) return containsCall if (!inverted) return containsCall
return FirFunctionCallImpl(session, base).apply { return FirFunctionCallImpl(base).apply {
calleeReference = FirSimpleNamedReference(session, operationReference, OperatorNameConventions.NOT) calleeReference = FirSimpleNamedReference(operationReference, OperatorNameConventions.NOT)
explicitReceiver = containsCall explicitReceiver = containsCall
} }
} }
@@ -386,22 +380,22 @@ internal fun generateIncrementOrDecrementBlock(
convert: KtExpression.() -> FirExpression convert: KtExpression.() -> FirExpression
): FirExpression { ): FirExpression {
if (argument == null) { if (argument == null) {
return FirErrorExpressionImpl(session, argument, "Inc/dec without operand") return FirErrorExpressionImpl(argument, "Inc/dec without operand")
} }
return FirBlockImpl(session, baseExpression).apply { return FirBlockImpl(baseExpression).apply {
val tempName = Name.special("<unary>") val tempName = Name.special("<unary>")
val temporaryVariable = generateTemporaryVariable(session, baseExpression, tempName, argument.convert()) val temporaryVariable = generateTemporaryVariable(session, baseExpression, tempName, argument.convert())
statements += temporaryVariable statements += temporaryVariable
val resultName = Name.special("<unary-result>") val resultName = Name.special("<unary-result>")
val resultInitializer = FirFunctionCallImpl(session, baseExpression).apply { val resultInitializer = FirFunctionCallImpl(baseExpression).apply {
this.calleeReference = FirSimpleNamedReference(session, baseExpression.operationReference, callName) this.calleeReference = FirSimpleNamedReference(baseExpression.operationReference, callName)
this.explicitReceiver = generateResolvedAccessExpression(session, baseExpression, temporaryVariable) this.explicitReceiver = generateResolvedAccessExpression(baseExpression, temporaryVariable)
} }
val resultVar = generateTemporaryVariable(session, baseExpression, resultName, resultInitializer) val resultVar = generateTemporaryVariable(session, baseExpression, resultName, resultInitializer)
val assignment = argument.generateAssignment( val assignment = argument.generateAssignment(
session, baseExpression, session, baseExpression,
if (prefix && argument !is KtSimpleNameExpression) if (prefix && argument !is KtSimpleNameExpression)
generateResolvedAccessExpression(session, baseExpression, resultVar) generateResolvedAccessExpression(baseExpression, resultVar)
else else
resultInitializer, resultInitializer,
FirOperation.ASSIGN, convert FirOperation.ASSIGN, convert
@@ -419,26 +413,26 @@ internal fun generateIncrementOrDecrementBlock(
if (argument !is KtSimpleNameExpression) { if (argument !is KtSimpleNameExpression) {
statements += resultVar statements += resultVar
appendAssignment() appendAssignment()
statements += generateResolvedAccessExpression(session, baseExpression, resultVar) statements += generateResolvedAccessExpression(baseExpression, resultVar)
} else { } else {
appendAssignment() appendAssignment()
statements += generateAccessExpression(session, baseExpression, argument.getReferencedNameAsName()) statements += generateAccessExpression(baseExpression, argument.getReferencedNameAsName())
} }
} else { } else {
appendAssignment() appendAssignment()
statements += generateResolvedAccessExpression(session, baseExpression, temporaryVariable) statements += generateResolvedAccessExpression(baseExpression, temporaryVariable)
} }
} }
} }
internal fun generateAccessExpression(session: FirSession, psi: PsiElement?, name: Name): FirQualifiedAccessExpression = internal fun generateAccessExpression(psi: PsiElement?, name: Name): FirQualifiedAccessExpression =
FirQualifiedAccessExpressionImpl(session, psi).apply { FirQualifiedAccessExpressionImpl(psi).apply {
calleeReference = FirSimpleNamedReference(session, psi, name) calleeReference = FirSimpleNamedReference(psi, name)
} }
internal fun generateResolvedAccessExpression(session: FirSession, psi: PsiElement?, variable: FirVariable<*>): FirQualifiedAccessExpression = internal fun generateResolvedAccessExpression(psi: PsiElement?, variable: FirVariable<*>): FirQualifiedAccessExpression =
FirQualifiedAccessExpressionImpl(session, psi).apply { FirQualifiedAccessExpressionImpl(psi).apply {
calleeReference = FirResolvedCallableReferenceImpl(session, psi, variable.name, variable.symbol) calleeReference = FirResolvedCallableReferenceImpl(psi, variable.name, variable.symbol)
} }
internal fun generateDestructuringBlock( internal fun generateDestructuringBlock(
@@ -449,7 +443,7 @@ internal fun generateDestructuringBlock(
extractAnnotationsTo: KtAnnotated.(FirAbstractAnnotatedElement) -> Unit, extractAnnotationsTo: KtAnnotated.(FirAbstractAnnotatedElement) -> Unit,
toFirOrImplicitTypeRef: KtTypeReference?.() -> FirTypeRef toFirOrImplicitTypeRef: KtTypeReference?.() -> FirTypeRef
): FirExpression { ): FirExpression {
return FirBlockImpl(session, multiDeclaration).apply { return FirBlockImpl(multiDeclaration).apply {
if (tmpVariable) { if (tmpVariable) {
statements += container statements += container
} }
@@ -458,7 +452,7 @@ internal fun generateDestructuringBlock(
statements += FirVariableImpl( statements += FirVariableImpl(
session, entry, entry.nameAsSafeName, session, entry, entry.nameAsSafeName,
entry.typeReference.toFirOrImplicitTypeRef(), isVar, entry.typeReference.toFirOrImplicitTypeRef(), isVar,
FirComponentCallImpl(session, entry, index + 1, generateResolvedAccessExpression(session, entry, container)), FirComponentCallImpl(entry, index + 1, generateResolvedAccessExpression(entry, container)),
FirVariableSymbol(entry.nameAsSafeName) // TODO? FirVariableSymbol(entry.nameAsSafeName) // TODO?
).apply { ).apply {
entry.extractAnnotationsTo(this) entry.extractAnnotationsTo(this)
@@ -471,7 +465,7 @@ internal fun generateDestructuringBlock(
internal fun generateTemporaryVariable( internal fun generateTemporaryVariable(
session: FirSession, psi: PsiElement?, name: Name, initializer: FirExpression session: FirSession, psi: PsiElement?, name: Name, initializer: FirExpression
): FirVariable<*> = ): FirVariable<*> =
FirVariableImpl(session, psi, name, FirImplicitTypeRefImpl(session, psi), false, initializer, FirVariableSymbol(name)).apply { FirVariableImpl(session, psi, name, FirImplicitTypeRefImpl(psi), false, initializer, FirVariableSymbol(name)).apply {
symbol.bind(this) symbol.bind(this)
} }
@@ -480,16 +474,15 @@ internal fun generateTemporaryVariable(
): FirVariable<*> = generateTemporaryVariable(session, psi, Name.special("<$specialName>"), initializer) ): FirVariable<*> = generateTemporaryVariable(session, psi, Name.special("<$specialName>"), initializer)
private fun FirModifiableQualifiedAccess<*>.initializeLValue( private fun FirModifiableQualifiedAccess<*>.initializeLValue(
session: FirSession,
left: KtExpression?, left: KtExpression?,
convertQualified: KtQualifiedExpression.() -> FirQualifiedAccess? convertQualified: KtQualifiedExpression.() -> FirQualifiedAccess?
): FirReference { ): FirReference {
return when (left) { return when (left) {
is KtSimpleNameExpression -> { is KtSimpleNameExpression -> {
FirSimpleNamedReference(session, left, left.getReferencedNameAsName()) FirSimpleNamedReference(left, left.getReferencedNameAsName())
} }
is KtThisExpression -> { is KtThisExpression -> {
FirExplicitThisReference(session, left, left.getLabelName()) FirExplicitThisReference(left, left.getLabelName())
} }
is KtQualifiedExpression -> { is KtQualifiedExpression -> {
val firMemberAccess = left.convertQualified() val firMemberAccess = left.convertQualified()
@@ -498,14 +491,14 @@ private fun FirModifiableQualifiedAccess<*>.initializeLValue(
safe = firMemberAccess.safe safe = firMemberAccess.safe
firMemberAccess.calleeReference firMemberAccess.calleeReference
} else { } else {
FirErrorNamedReference(session, left, "Unsupported qualified LValue: ${left.text}") FirErrorNamedReference(left, "Unsupported qualified LValue: ${left.text}")
} }
} }
is KtParenthesizedExpression -> { is KtParenthesizedExpression -> {
initializeLValue(session, left.expression, convertQualified) initializeLValue(left.expression, convertQualified)
} }
else -> { else -> {
FirErrorNamedReference(session, left, "Unsupported LValue: ${left?.javaClass}") FirErrorNamedReference(left, "Unsupported LValue: ${left?.javaClass}")
} }
} }
} }
@@ -522,16 +515,16 @@ internal fun KtExpression?.generateAssignment(
} }
if (this is KtArrayAccessExpression) { if (this is KtArrayAccessExpression) {
val arrayExpression = this.arrayExpression val arrayExpression = this.arrayExpression
val firArrayExpression = arrayExpression?.convert() ?: FirErrorExpressionImpl(session, arrayExpression, "No array expression") val firArrayExpression = arrayExpression?.convert() ?: FirErrorExpressionImpl(arrayExpression, "No array expression")
val arraySet = if (operation != FirOperation.ASSIGN) { val arraySet = if (operation != FirOperation.ASSIGN) {
FirArraySetCallImpl(session, psi, value, operation).apply { FirArraySetCallImpl(psi, value, operation).apply {
for (indexExpression in indexExpressions) { for (indexExpression in indexExpressions) {
indexes += indexExpression.convert() indexes += indexExpression.convert()
} }
} }
} else { } else {
return FirFunctionCallImpl(session, psi).apply { return FirFunctionCallImpl(psi).apply {
calleeReference = FirSimpleNamedReference(session, psi, OperatorNameConventions.SET) calleeReference = FirSimpleNamedReference(psi, OperatorNameConventions.SET)
explicitReceiver = firArrayExpression explicitReceiver = firArrayExpression
for (indexExpression in indexExpressions) { for (indexExpression in indexExpressions) {
arguments += indexExpression.convert() arguments += indexExpression.convert()
@@ -541,32 +534,32 @@ internal fun KtExpression?.generateAssignment(
} }
if (arrayExpression is KtSimpleNameExpression) { if (arrayExpression is KtSimpleNameExpression) {
return arraySet.apply { return arraySet.apply {
lValue = initializeLValue(session, arrayExpression) { convert() as? FirQualifiedAccess } lValue = initializeLValue(arrayExpression) { convert() as? FirQualifiedAccess }
} }
} }
return FirBlockImpl(session, arrayExpression).apply { return FirBlockImpl(arrayExpression).apply {
val name = Name.special("<array-set>") val name = Name.special("<array-set>")
statements += generateTemporaryVariable(session, this@generateAssignment, name, firArrayExpression) statements += generateTemporaryVariable(session, this@generateAssignment, name, firArrayExpression)
statements += arraySet.apply { lValue = FirSimpleNamedReference(session, arrayExpression, name) } statements += arraySet.apply { lValue = FirSimpleNamedReference(arrayExpression, name) }
} }
} }
if (operation != FirOperation.ASSIGN && if (operation != FirOperation.ASSIGN &&
this !is KtSimpleNameExpression && this !is KtThisExpression && this !is KtSimpleNameExpression && this !is KtThisExpression &&
(this !is KtQualifiedExpression || selectorExpression !is KtSimpleNameExpression) (this !is KtQualifiedExpression || selectorExpression !is KtSimpleNameExpression)
) { ) {
return FirBlockImpl(session, this).apply { return FirBlockImpl(this).apply {
val name = Name.special("<complex-set>") val name = Name.special("<complex-set>")
statements += generateTemporaryVariable( statements += generateTemporaryVariable(
session, this@generateAssignment, name, session, this@generateAssignment, name,
this@generateAssignment?.convert() ?: FirErrorExpressionImpl(session, this@generateAssignment, "No LValue in assignment") this@generateAssignment?.convert() ?: FirErrorExpressionImpl(this@generateAssignment, "No LValue in assignment")
) )
statements += FirVariableAssignmentImpl(session, psi, value, operation).apply { statements += FirVariableAssignmentImpl(psi, value, operation).apply {
lValue = FirSimpleNamedReference(session, this@generateAssignment, name) lValue = FirSimpleNamedReference(this@generateAssignment, name)
} }
} }
} }
return FirVariableAssignmentImpl(session, psi, value, operation).apply { return FirVariableAssignmentImpl(psi, value, operation).apply {
lValue = initializeLValue(session, this@generateAssignment) { convert() as? FirQualifiedAccess } lValue = initializeLValue(this@generateAssignment) { convert() as? FirQualifiedAccess }
} }
} }
@@ -574,37 +567,36 @@ internal fun FirModifiableAccessorsOwner.generateAccessorsByDelegate(session: Fi
val variable = this as FirVariable<*> val variable = this as FirVariable<*>
val delegateFieldSymbol = delegateFieldSymbol ?: return val delegateFieldSymbol = delegateFieldSymbol ?: return
val delegate = delegate as? FirWrappedDelegateExpressionImpl ?: return val delegate = delegate as? FirWrappedDelegateExpressionImpl ?: return
fun delegateAccess() = FirQualifiedAccessExpressionImpl(session, null).apply { fun delegateAccess() = FirQualifiedAccessExpressionImpl(null).apply {
calleeReference = FirDelegateFieldReferenceImpl(session, null, delegateFieldSymbol) calleeReference = FirDelegateFieldReferenceImpl(null, delegateFieldSymbol)
} }
fun thisRef() = fun thisRef() =
if (member) FirQualifiedAccessExpressionImpl(session, null).apply { if (member) FirQualifiedAccessExpressionImpl(null).apply {
calleeReference = FirExplicitThisReference(session, null, null) calleeReference = FirExplicitThisReference(null, null)
} }
else FirConstExpressionImpl(session, null, IrConstKind.Null, null) else FirConstExpressionImpl(null, IrConstKind.Null, null)
fun propertyRef() = FirCallableReferenceAccessImpl(session, null).apply { fun propertyRef() = FirCallableReferenceAccessImpl(null).apply {
calleeReference = FirResolvedCallableReferenceImpl(session, null, variable.name, variable.symbol) calleeReference = FirResolvedCallableReferenceImpl(null, variable.name, variable.symbol)
typeRef = FirImplicitKPropertyTypeRef(session, null, ConeStarProjection) typeRef = FirImplicitKPropertyTypeRef(null, ConeStarProjection)
} }
delegate.delegateProvider = if (stubMode) FirExpressionStub(session, null) else FirFunctionCallImpl(session, null).apply { delegate.delegateProvider = if (stubMode) FirExpressionStub(null) else FirFunctionCallImpl(null).apply {
explicitReceiver = delegate.expression explicitReceiver = delegate.expression
calleeReference = FirSimpleNamedReference(session, null, PROVIDE_DELEGATE) calleeReference = FirSimpleNamedReference(null, PROVIDE_DELEGATE)
arguments += thisRef() arguments += thisRef()
arguments += propertyRef() arguments += propertyRef()
} }
if (stubMode) return if (stubMode) return
getter = (getter as? FirPropertyAccessorImpl) getter = (getter as? FirPropertyAccessorImpl)
?: FirPropertyAccessorImpl(session, null, true, Visibilities.UNKNOWN, FirImplicitTypeRefImpl(session, null)).apply Accessor@{ ?: FirPropertyAccessorImpl(session, null, true, Visibilities.UNKNOWN, FirImplicitTypeRefImpl(null)).apply Accessor@{
body = FirSingleExpressionBlock( body = FirSingleExpressionBlock(
session,
FirReturnExpressionImpl( FirReturnExpressionImpl(
session, null, null,
FirFunctionCallImpl(session, null).apply { FirFunctionCallImpl(null).apply {
explicitReceiver = delegateAccess() explicitReceiver = delegateAccess()
calleeReference = FirSimpleNamedReference(session, null, GET_VALUE) calleeReference = FirSimpleNamedReference(null, GET_VALUE)
arguments += thisRef() arguments += thisRef()
arguments += propertyRef() arguments += propertyRef()
} }
@@ -615,22 +607,22 @@ internal fun FirModifiableAccessorsOwner.generateAccessorsByDelegate(session: Fi
) )
} }
setter = (setter as? FirPropertyAccessorImpl) setter = (setter as? FirPropertyAccessorImpl)
?: FirPropertyAccessorImpl(session, null, false, Visibilities.UNKNOWN, FirImplicitUnitTypeRef(session, null)).apply { ?: FirPropertyAccessorImpl(session, null, false, Visibilities.UNKNOWN, FirImplicitUnitTypeRef(null)).apply {
val parameter = FirValueParameterImpl( val parameter = FirValueParameterImpl(
session, null, DELEGATED_SETTER_PARAM, session, null, DELEGATED_SETTER_PARAM,
FirImplicitTypeRefImpl(session, null), FirImplicitTypeRefImpl(null),
defaultValue = null, isCrossinline = false, defaultValue = null, isCrossinline = false,
isNoinline = false, isVararg = false isNoinline = false, isVararg = false
) )
valueParameters += parameter valueParameters += parameter
body = FirSingleExpressionBlock( body = FirSingleExpressionBlock(
session, FirFunctionCallImpl(session, null).apply { FirFunctionCallImpl(null).apply {
explicitReceiver = delegateAccess() explicitReceiver = delegateAccess()
calleeReference = FirSimpleNamedReference(session, null, SET_VALUE) calleeReference = FirSimpleNamedReference(null, SET_VALUE)
arguments += thisRef() arguments += thisRef()
arguments += propertyRef() arguments += propertyRef()
arguments += FirQualifiedAccessExpressionImpl(session, null).apply { arguments += FirQualifiedAccessExpressionImpl(null).apply {
calleeReference = FirResolvedCallableReferenceImpl(session, psi, DELEGATED_SETTER_PARAM, parameter.symbol) calleeReference = FirResolvedCallableReferenceImpl(psi, DELEGATED_SETTER_PARAM, parameter.symbol)
} }
} }
) )
compiler/fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/DataClassUtils.kt
+7 -8
View File
@@ -45,17 +45,16 @@ internal fun KtClassOrObject.generateComponentFunctions(
isInfix = false, isInline = false, isInfix = false, isInline = false,
isTailRec = false, isExternal = false, isTailRec = false, isExternal = false,
isSuspend = false, receiverTypeRef = null, isSuspend = false, receiverTypeRef = null,
returnTypeRef = FirImplicitTypeRefImpl(session, ktParameter) returnTypeRef = FirImplicitTypeRefImpl(ktParameter)
).apply { ).apply {
val componentFunction = this val componentFunction = this
body = FirSingleExpressionBlock( body = FirSingleExpressionBlock(
session,
FirReturnExpressionImpl( FirReturnExpressionImpl(
session, ktParameter, ktParameter,
FirQualifiedAccessExpressionImpl(session, ktParameter).apply { FirQualifiedAccessExpressionImpl(ktParameter).apply {
val parameterName = ktParameter.nameAsSafeName val parameterName = ktParameter.nameAsSafeName
calleeReference = FirResolvedCallableReferenceImpl( calleeReference = FirResolvedCallableReferenceImpl(
session, ktParameter, ktParameter,
parameterName, firProperty.symbol parameterName, firProperty.symbol
) )
} }
@@ -96,14 +95,14 @@ internal fun KtClassOrObject.generateCopyFunction(
valueParameters += FirValueParameterImpl( valueParameters += FirValueParameterImpl(
session, ktParameter, name, session, ktParameter, name,
ktParameter.typeReference.toFirOrErrorTypeRef(), ktParameter.typeReference.toFirOrErrorTypeRef(),
FirQualifiedAccessExpressionImpl(session, ktParameter).apply { FirQualifiedAccessExpressionImpl(ktParameter).apply {
calleeReference = FirResolvedCallableReferenceImpl(session, ktParameter, name, firProperty.symbol) calleeReference = FirResolvedCallableReferenceImpl(ktParameter, name, firProperty.symbol)
}, },
isCrossinline = false, isNoinline = false, isVararg = false isCrossinline = false, isNoinline = false, isVararg = false
) )
} }
body = FirEmptyExpressionBlock(session) body = FirEmptyExpressionBlock()
// body = FirSingleExpressionBlock( // body = FirSingleExpressionBlock(
// session, // session,
// FirReturnExpressionImpl( // FirReturnExpressionImpl(
compiler/fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/RawFirBuilder.kt
+107 -140
View File
@@ -35,13 +35,13 @@ import org.jetbrains.kotlin.util.OperatorNameConventions
class RawFirBuilder(val session: FirSession, val stubMode: Boolean) { class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {
private val implicitUnitType = FirImplicitUnitTypeRef(session, null) private val implicitUnitType = FirImplicitUnitTypeRef(null)
private val implicitAnyType = FirImplicitAnyTypeRef(session, null) private val implicitAnyType = FirImplicitAnyTypeRef(null)
private val implicitEnumType = FirImplicitEnumTypeRef(session, null) private val implicitEnumType = FirImplicitEnumTypeRef(null)
private val implicitAnnotationType = FirImplicitAnnotationTypeRef(session, null) private val implicitAnnotationType = FirImplicitAnnotationTypeRef(null)
fun buildFirFile(file: KtFile): FirFile { fun buildFirFile(file: KtFile): FirFile {
return file.accept(Visitor(), Unit) as FirFile return file.accept(Visitor(), Unit) as FirFile
@@ -77,27 +77,27 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {
this.accept(this@Visitor, Unit) as R this.accept(this@Visitor, Unit) as R
private fun KtTypeReference?.toFirOrImplicitType(): FirTypeRef = private fun KtTypeReference?.toFirOrImplicitType(): FirTypeRef =
convertSafe() ?: FirImplicitTypeRefImpl(session, this) convertSafe() ?: FirImplicitTypeRefImpl(this)
private fun KtTypeReference?.toFirOrUnitType(): FirTypeRef = private fun KtTypeReference?.toFirOrUnitType(): FirTypeRef =
convertSafe() ?: implicitUnitType convertSafe() ?: implicitUnitType
private fun KtTypeReference?.toFirOrErrorType(): FirTypeRef = private fun KtTypeReference?.toFirOrErrorType(): FirTypeRef =
convertSafe() ?: FirErrorTypeRefImpl(session, this, if (this == null) "Incomplete code" else "Conversion failed") convertSafe() ?: FirErrorTypeRefImpl(this, if (this == null) "Incomplete code" else "Conversion failed")
// Here we accept lambda as receiver to prevent expression calculation in stub mode // Here we accept lambda as receiver to prevent expression calculation in stub mode
private fun (() -> KtExpression?).toFirExpression(errorReason: String): FirExpression = private fun (() -> KtExpression?).toFirExpression(errorReason: String): FirExpression =
if (stubMode) FirExpressionStub(session, null) if (stubMode) FirExpressionStub(null)
else with(this()) { else with(this()) {
convertSafe<FirExpression>() ?: FirErrorExpressionImpl(session, this, errorReason) convertSafe<FirExpression>() ?: FirErrorExpressionImpl(this, errorReason)
} }
private fun KtExpression?.toFirExpression(errorReason: String): FirExpression = private fun KtExpression?.toFirExpression(errorReason: String): FirExpression =
if (stubMode) FirExpressionStub(session, null) if (stubMode) FirExpressionStub(null)
else convertSafe<FirExpression>() ?: FirErrorExpressionImpl(session, this, errorReason) else convertSafe<FirExpression>() ?: FirErrorExpressionImpl(this, errorReason)
private fun KtExpression.toFirStatement(errorReason: String): FirStatement = private fun KtExpression.toFirStatement(errorReason: String): FirStatement =
convertSafe() ?: FirErrorExpressionImpl(session, this, errorReason) convertSafe() ?: FirErrorExpressionImpl(this, errorReason)
private fun KtExpression.toFirStatement(): FirStatement = private fun KtExpression.toFirStatement(): FirStatement =
convert() convert()
@@ -108,7 +108,7 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {
return when (this) { return when (this) {
is KtSecondaryConstructor -> toFirConstructor( is KtSecondaryConstructor -> toFirConstructor(
delegatedSuperType, delegatedSuperType,
delegatedSelfType ?: FirErrorTypeRefImpl(this@RawFirBuilder.session, this, "Constructor in object"), delegatedSelfType ?: FirErrorTypeRefImpl(this, "Constructor in object"),
owner, owner,
hasPrimaryConstructor hasPrimaryConstructor
) )
@@ -121,20 +121,13 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {
is KtBlockExpression -> is KtBlockExpression ->
accept(this@Visitor, Unit) as FirBlock accept(this@Visitor, Unit) as FirBlock
null -> null ->
FirEmptyExpressionBlock(session) FirEmptyExpressionBlock()
else -> else ->
FirSingleExpressionBlock( FirSingleExpressionBlock(convert())
session,
convert()
)
} }
private fun FirExpression.toReturn(basePsi: PsiElement? = psi, labelName: String? = null): FirReturnExpression { private fun FirExpression.toReturn(basePsi: PsiElement? = psi, labelName: String? = null): FirReturnExpression {
return FirReturnExpressionImpl( return FirReturnExpressionImpl(basePsi, this).apply {
this@RawFirBuilder.session,
basePsi,
this
).apply {
target = FirFunctionTarget(labelName) target = FirFunctionTarget(labelName)
val lastFunction = firFunctions.lastOrNull() val lastFunction = firFunctions.lastOrNull()
if (labelName == null) { if (labelName == null) {
@@ -172,22 +165,16 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {
hasBlockBody() -> if (!stubMode) { hasBlockBody() -> if (!stubMode) {
bodyBlockExpression?.accept(this@Visitor, Unit) as? FirBlock bodyBlockExpression?.accept(this@Visitor, Unit) as? FirBlock
} else { } else {
FirSingleExpressionBlock( FirSingleExpressionBlock(FirExpressionStub(this).toReturn())
session,
FirExpressionStub(session, this).toReturn()
)
} }
else -> { else -> {
val result = { bodyExpression }.toFirExpression("Function has no body (but should)") val result = { bodyExpression }.toFirExpression("Function has no body (but should)")
FirSingleExpressionBlock( FirSingleExpressionBlock(result.toReturn())
session,
result.toReturn()
)
} }
} }
private fun ValueArgument?.toFirExpression(): FirExpression { private fun ValueArgument?.toFirExpression(): FirExpression {
this ?: return FirErrorExpressionImpl(session, this as? KtElement, "No argument given") this ?: return FirErrorExpressionImpl(this as? KtElement, "No argument given")
val name = this.getArgumentName()?.asName val name = this.getArgumentName()?.asName
val expression = this.getArgumentExpression() val expression = this.getArgumentExpression()
val firExpression = when (expression) { val firExpression = when (expression) {
@@ -201,8 +188,8 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {
} }
val isSpread = getSpreadElement() != null val isSpread = getSpreadElement() != null
return when { return when {
name != null -> FirNamedArgumentExpressionImpl(session, expression, name, isSpread, firExpression) name != null -> FirNamedArgumentExpressionImpl(expression, name, isSpread, firExpression)
isSpread -> FirSpreadArgumentExpressionImpl(session, expression, firExpression) isSpread -> FirSpreadArgumentExpressionImpl(expression, firExpression)
else -> firExpression else -> firExpression
} }
} }
@@ -280,9 +267,9 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {
receiverTypeRef = null, receiverTypeRef = null,
returnTypeRef = type, returnTypeRef = type,
isVar = isMutable, isVar = isMutable,
initializer = FirQualifiedAccessExpressionImpl(session, this).apply { initializer = FirQualifiedAccessExpressionImpl(this).apply {
calleeReference = FirPropertyFromParameterCallableReference( calleeReference = FirPropertyFromParameterCallableReference(
this@RawFirBuilder.session, this@toFirProperty, nameAsSafeName, firParameter.symbol this@toFirProperty, nameAsSafeName, firParameter.symbol
) )
}, },
delegate = null delegate = null
@@ -319,7 +306,7 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {
for (argument in this.valueArguments) { for (argument in this.valueArguments) {
val argumentExpression = argument.toFirExpression() val argumentExpression = argument.toFirExpression()
container.arguments += when (argument) { container.arguments += when (argument) {
is KtLambdaArgument -> FirLambdaArgumentExpressionImpl(session, argument, argumentExpression) is KtLambdaArgument -> FirLambdaArgumentExpressionImpl(argument, argumentExpression)
else -> argumentExpression else -> argumentExpression
} }
} }
@@ -343,7 +330,7 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {
is KtDelegatedSuperTypeEntry -> { is KtDelegatedSuperTypeEntry -> {
val type = superTypeListEntry.typeReference.toFirOrErrorType() val type = superTypeListEntry.typeReference.toFirOrErrorType()
container.superTypeRefs += FirDelegatedTypeRefImpl( container.superTypeRefs += FirDelegatedTypeRefImpl(
session, type, type,
{ superTypeListEntry.delegateExpression }.toFirExpression("Should have delegate") { superTypeListEntry.delegateExpression }.toFirExpression("Should have delegate")
) )
} }
@@ -384,7 +371,6 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {
): FirConstructor { ): FirConstructor {
val constructorCallee = superTypeCallEntry?.calleeExpression val constructorCallee = superTypeCallEntry?.calleeExpression
val firDelegatedCall = FirDelegatedConstructorCallImpl( val firDelegatedCall = FirDelegatedConstructorCallImpl(
session,
constructorCallee ?: (this ?: owner), constructorCallee ?: (this ?: owner),
delegatedSuperTypeRef, delegatedSuperTypeRef,
isThis = false isThis = false
@@ -427,7 +413,6 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {
} }
for (importDirective in file.importDirectives) { for (importDirective in file.importDirectives) {
firFile.imports += FirImportImpl( firFile.imports += FirImportImpl(
session,
importDirective, importDirective,
importDirective.importedFqName, importDirective.importedFqName,
importDirective.isAllUnder, importDirective.isAllUnder,
@@ -448,7 +433,6 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {
} }
} }
return FirResolvedTypeRefImpl( return FirResolvedTypeRefImpl(
session,
this, this,
ConeClassTypeImpl( ConeClassTypeImpl(
firClass.symbol.toLookupTag(), firClass.symbol.toLookupTag(),
@@ -460,7 +444,7 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {
private fun FirTypeParameterImpl.addDefaultBoundIfNecessary() { private fun FirTypeParameterImpl.addDefaultBoundIfNecessary() {
if (bounds.isEmpty()) { if (bounds.isEmpty()) {
bounds += FirImplicitNullableAnyTypeRef(session, null) bounds += FirImplicitNullableAnyTypeRef(null)
} }
} }
@@ -572,7 +556,7 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {
override fun visitObjectLiteralExpression(expression: KtObjectLiteralExpression, data: Unit): FirElement { override fun visitObjectLiteralExpression(expression: KtObjectLiteralExpression, data: Unit): FirElement {
val objectDeclaration = expression.objectDeclaration val objectDeclaration = expression.objectDeclaration
return FirAnonymousObjectImpl(session, expression).apply { return FirAnonymousObjectImpl(expression).apply {
objectDeclaration.extractAnnotationsTo(this) objectDeclaration.extractAnnotationsTo(this)
objectDeclaration.extractSuperTypeListEntriesTo(this, null) objectDeclaration.extractSuperTypeListEntriesTo(this, null)
this.typeRef = superTypeRefs.first() // TODO this.typeRef = superTypeRefs.first() // TODO
@@ -665,8 +649,8 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {
override fun visitLambdaExpression(expression: KtLambdaExpression, data: Unit): FirElement { override fun visitLambdaExpression(expression: KtLambdaExpression, data: Unit): FirElement {
val literal = expression.functionLiteral val literal = expression.functionLiteral
val returnType = FirImplicitTypeRefImpl(session, literal) val returnType = FirImplicitTypeRefImpl(literal)
val receiverType = FirImplicitTypeRefImpl(session, literal) val receiverType = FirImplicitTypeRefImpl(literal)
return FirAnonymousFunctionImpl(session, literal, returnType, receiverType).apply { return FirAnonymousFunctionImpl(session, literal, returnType, receiverType).apply {
firFunctions += this firFunctions += this
var destructuringBlock: FirExpression? = null var destructuringBlock: FirExpression? = null
@@ -675,7 +659,7 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {
valueParameters += if (multiDeclaration != null) { valueParameters += if (multiDeclaration != null) {
val multiParameter = FirValueParameterImpl( val multiParameter = FirValueParameterImpl(
this@RawFirBuilder.session, valueParameter, Name.special("<destruct>"), this@RawFirBuilder.session, valueParameter, Name.special("<destruct>"),
FirImplicitTypeRefImpl(this@RawFirBuilder.session, multiDeclaration), FirImplicitTypeRefImpl(multiDeclaration),
defaultValue = null, isCrossinline = false, isNoinline = false, isVararg = false defaultValue = null, isCrossinline = false, isNoinline = false, isVararg = false
) )
destructuringBlock = generateDestructuringBlock( destructuringBlock = generateDestructuringBlock(
@@ -687,16 +671,16 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {
) { toFirOrImplicitType() } ) { toFirOrImplicitType() }
multiParameter multiParameter
} else { } else {
valueParameter.toFirValueParameter(FirImplicitTypeRefImpl(this@RawFirBuilder.session, psi)) valueParameter.toFirValueParameter(FirImplicitTypeRefImpl(psi))
} }
} }
label = firLabels.pop() ?: firFunctionCalls.lastOrNull()?.calleeReference?.name?.let { label = firLabels.pop() ?: firFunctionCalls.lastOrNull()?.calleeReference?.name?.let {
FirLabelImpl(this@RawFirBuilder.session, expression, it.asString()) FirLabelImpl(expression, it.asString())
} }
val bodyExpression = literal.bodyExpression.toFirExpression("Lambda has no body") val bodyExpression = literal.bodyExpression.toFirExpression("Lambda has no body")
body = if (bodyExpression is FirBlockImpl) { body = if (bodyExpression is FirBlockImpl) {
if (bodyExpression.statements.isEmpty()) { if (bodyExpression.statements.isEmpty()) {
bodyExpression.statements.add(FirUnitExpression(this@RawFirBuilder.session, expression)) bodyExpression.statements.add(FirUnitExpression(expression))
} }
if (destructuringBlock is FirBlock) { if (destructuringBlock is FirBlock) {
for ((index, statement) in destructuringBlock.statements.withIndex()) { for ((index, statement) in destructuringBlock.statements.withIndex()) {
@@ -705,7 +689,7 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {
} }
bodyExpression bodyExpression
} else { } else {
FirSingleExpressionBlock(this@RawFirBuilder.session, bodyExpression.toReturn()) FirSingleExpressionBlock(bodyExpression.toReturn())
} }
firFunctions.removeLast() firFunctions.removeLast()
@@ -752,10 +736,9 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {
val isThis = isCallToThis || (isImplicit && hasPrimaryConstructor) val isThis = isCallToThis || (isImplicit && hasPrimaryConstructor)
val delegatedType = when { val delegatedType = when {
isThis -> delegatedSelfTypeRef isThis -> delegatedSelfTypeRef
else -> delegatedSuperTypeRef ?: FirErrorTypeRefImpl(session, this, "No super type") else -> delegatedSuperTypeRef ?: FirErrorTypeRefImpl(this, "No super type")
} }
return FirDelegatedConstructorCallImpl( return FirDelegatedConstructorCallImpl(
session,
this, this,
delegatedType, delegatedType,
isThis isThis
@@ -770,7 +753,7 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {
return FirAnonymousInitializerImpl( return FirAnonymousInitializerImpl(
session, session,
initializer, initializer,
if (stubMode) FirEmptyExpressionBlock(session) else initializer.body.toFirBlock() if (stubMode) FirEmptyExpressionBlock() else initializer.body.toFirBlock()
) )
} }
@@ -792,7 +775,7 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {
initializer, initializer,
delegate = delegateExpression?.let { delegate = delegateExpression?.let {
FirWrappedDelegateExpressionImpl( FirWrappedDelegateExpressionImpl(
session, it, it,
it.toFirExpression("Incorrect delegate expression") it.toFirExpression("Incorrect delegate expression")
) )
} }
@@ -818,7 +801,7 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {
initializer, initializer,
if (property.hasDelegate()) { if (property.hasDelegate()) {
FirWrappedDelegateExpressionImpl( FirWrappedDelegateExpressionImpl(
session, if (stubMode) null else delegateExpression, if (stubMode) null else delegateExpression,
{ delegateExpression }.toFirExpression("Should have delegate") { delegateExpression }.toFirExpression("Should have delegate")
) )
} else null } else null
@@ -841,12 +824,12 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {
if (this is KtNullableType) this.innerType.unwrapNullable() else this if (this is KtNullableType) this.innerType.unwrapNullable() else this
val firType = when (val unwrappedElement = typeElement.unwrapNullable()) { val firType = when (val unwrappedElement = typeElement.unwrapNullable()) {
is KtDynamicType -> FirDynamicTypeRefImpl(session, typeReference, isNullable) is KtDynamicType -> FirDynamicTypeRefImpl(typeReference, isNullable)
is KtUserType -> { is KtUserType -> {
var referenceExpression = unwrappedElement.referenceExpression var referenceExpression = unwrappedElement.referenceExpression
if (referenceExpression != null) { if (referenceExpression != null) {
val userType = FirUserTypeRefImpl( val userType = FirUserTypeRefImpl(
session, typeReference, isNullable typeReference, isNullable
) )
var qualifier: KtUserType? = unwrappedElement var qualifier: KtUserType? = unwrappedElement
do { do {
@@ -864,12 +847,11 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {
userType userType
} else { } else {
FirErrorTypeRefImpl(session, typeReference, "Incomplete user type") FirErrorTypeRefImpl(typeReference, "Incomplete user type")
} }
} }
is KtFunctionType -> { is KtFunctionType -> {
val functionType = FirFunctionTypeRefImpl( val functionType = FirFunctionTypeRefImpl(
session,
typeReference, typeReference,
isNullable, isNullable,
unwrappedElement.receiverTypeReference.convertSafe(), unwrappedElement.receiverTypeReference.convertSafe(),
@@ -881,7 +863,7 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {
} }
functionType functionType
} }
null -> FirErrorTypeRefImpl(session, typeReference, "Unwrapped type is null") null -> FirErrorTypeRefImpl(typeReference, "Unwrapped type is null")
else -> throw AssertionError("Unexpected type element: ${unwrappedElement.text}") else -> throw AssertionError("Unexpected type element: ${unwrappedElement.text}")
} }
@@ -893,7 +875,6 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {
override fun visitAnnotationEntry(annotationEntry: KtAnnotationEntry, data: Unit): FirElement { override fun visitAnnotationEntry(annotationEntry: KtAnnotationEntry, data: Unit): FirElement {
val firAnnotationCall = FirAnnotationCallImpl( val firAnnotationCall = FirAnnotationCallImpl(
session,
annotationEntry, annotationEntry,
annotationEntry.useSiteTarget?.getAnnotationUseSiteTarget(), annotationEntry.useSiteTarget?.getAnnotationUseSiteTarget(),
annotationEntry.typeReference.toFirOrErrorType() annotationEntry.typeReference.toFirOrErrorType()
@@ -931,7 +912,7 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {
override fun visitTypeProjection(typeProjection: KtTypeProjection, data: Unit): FirElement { override fun visitTypeProjection(typeProjection: KtTypeProjection, data: Unit): FirElement {
val projectionKind = typeProjection.projectionKind val projectionKind = typeProjection.projectionKind
if (projectionKind == KtProjectionKind.STAR) { if (projectionKind == KtProjectionKind.STAR) {
return FirStarProjectionImpl(session, typeProjection) return FirStarProjectionImpl(typeProjection)
} }
if (projectionKind == KtProjectionKind.NONE && typeProjection.text == "_") { if (projectionKind == KtProjectionKind.NONE && typeProjection.text == "_") {
return FirTypePlaceholderProjection return FirTypePlaceholderProjection
@@ -939,7 +920,6 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {
val typeReference = typeProjection.typeReference val typeReference = typeProjection.typeReference
val firType = typeReference.toFirOrErrorType() val firType = typeReference.toFirOrErrorType()
return FirTypeProjectionWithVarianceImpl( return FirTypeProjectionWithVarianceImpl(
session,
typeProjection, typeProjection,
when (projectionKind) { when (projectionKind) {
KtProjectionKind.IN -> Variance.IN_VARIANCE KtProjectionKind.IN -> Variance.IN_VARIANCE
@@ -955,7 +935,7 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {
parameter.toFirValueParameter() parameter.toFirValueParameter()
override fun visitBlockExpression(expression: KtBlockExpression, data: Unit): FirElement { override fun visitBlockExpression(expression: KtBlockExpression, data: Unit): FirElement {
return FirBlockImpl(session, expression).apply { return FirBlockImpl(expression).apply {
for (statement in expression.statements) { for (statement in expression.statements) {
val firStatement = statement.toFirStatement("Statement expected: ${statement.text}") val firStatement = statement.toFirStatement("Statement expected: ${statement.text}")
if (firStatement !is FirBlock || firStatement.annotations.isNotEmpty()) { if (firStatement !is FirBlock || firStatement.annotations.isNotEmpty()) {
@@ -968,46 +948,43 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {
} }
override fun visitSimpleNameExpression(expression: KtSimpleNameExpression, data: Unit): FirElement { override fun visitSimpleNameExpression(expression: KtSimpleNameExpression, data: Unit): FirElement {
return generateAccessExpression(session, expression, expression.getReferencedNameAsName()) return generateAccessExpression(expression, expression.getReferencedNameAsName())
} }
override fun visitConstantExpression(expression: KtConstantExpression, data: Unit): FirElement = override fun visitConstantExpression(expression: KtConstantExpression, data: Unit): FirElement =
generateConstantExpressionByLiteral(session, expression) generateConstantExpressionByLiteral(expression)
override fun visitStringTemplateExpression(expression: KtStringTemplateExpression, data: Unit): FirElement { override fun visitStringTemplateExpression(expression: KtStringTemplateExpression, data: Unit): FirElement {
return expression.entries.toInterpolatingCall(session, expression) { toFirExpression(it) } return expression.entries.toInterpolatingCall(expression) { toFirExpression(it) }
} }
override fun visitReturnExpression(expression: KtReturnExpression, data: Unit): FirElement { override fun visitReturnExpression(expression: KtReturnExpression, data: Unit): FirElement {
val result = expression.returnedExpression?.toFirExpression("Incorrect return expression") val result = expression.returnedExpression?.toFirExpression("Incorrect return expression")
?: FirUnitExpression(session, expression) ?: FirUnitExpression(expression)
return result.toReturn(expression, expression.getTargetLabel()?.getReferencedName()) return result.toReturn(expression, expression.getTargetLabel()?.getReferencedName())
} }
override fun visitTryExpression(expression: KtTryExpression, data: Unit): FirElement { override fun visitTryExpression(expression: KtTryExpression, data: Unit): FirElement {
val tryBlock = expression.tryBlock.toFirBlock() val tryBlock = expression.tryBlock.toFirBlock()
val finallyBlock = expression.finallyBlock?.finalExpression?.toFirBlock() val finallyBlock = expression.finallyBlock?.finalExpression?.toFirBlock()
return FirTryExpressionImpl(session, expression, tryBlock, finallyBlock).apply { return FirTryExpressionImpl(expression, tryBlock, finallyBlock).apply {
for (clause in expression.catchClauses) { for (clause in expression.catchClauses) {
val parameter = clause.catchParameter?.toFirValueParameter() ?: continue val parameter = clause.catchParameter?.toFirValueParameter() ?: continue
val block = clause.catchBody.toFirBlock() val block = clause.catchBody.toFirBlock()
catches += FirCatchImpl(this@RawFirBuilder.session, clause, parameter, block) catches += FirCatchImpl(clause, parameter, block)
} }
} }
} }
override fun visitIfExpression(expression: KtIfExpression, data: Unit): FirElement { override fun visitIfExpression(expression: KtIfExpression, data: Unit): FirElement {
return FirWhenExpressionImpl( return FirWhenExpressionImpl(expression).apply {
session,
expression
).apply {
val condition = expression.condition val condition = expression.condition
val firCondition = condition.toFirExpression("If statement should have condition") val firCondition = condition.toFirExpression("If statement should have condition")
val trueBranch = expression.then.toFirBlock() val trueBranch = expression.then.toFirBlock()
branches += FirWhenBranchImpl(this@RawFirBuilder.session, condition, firCondition, trueBranch) branches += FirWhenBranchImpl(condition, firCondition, trueBranch)
val elseBranch = expression.`else`.toFirBlock() val elseBranch = expression.`else`.toFirBlock()
branches += FirWhenBranchImpl( branches += FirWhenBranchImpl(
this@RawFirBuilder.session, null, FirElseIfTrueCondition(this@RawFirBuilder.session, null), elseBranch null, FirElseIfTrueCondition(null), elseBranch
) )
} }
} }
@@ -1029,7 +1006,6 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {
val hasSubject = subjectExpression != null val hasSubject = subjectExpression != null
val subject = FirWhenSubject() val subject = FirWhenSubject()
return FirWhenExpressionImpl( return FirWhenExpressionImpl(
session,
expression, expression,
subjectExpression, subjectExpression,
subjectVariable subjectVariable
@@ -1042,22 +1018,19 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {
branches += if (!entry.isElse) { branches += if (!entry.isElse) {
if (hasSubject) { if (hasSubject) {
val firCondition = entry.conditions.toFirWhenCondition( val firCondition = entry.conditions.toFirWhenCondition(
this@RawFirBuilder.session,
entry, entry,
subject, subject,
{ toFirExpression(it) }, { toFirExpression(it) },
{ toFirOrErrorType() } { toFirOrErrorType() }
) )
FirWhenBranchImpl(this@RawFirBuilder.session, entry, firCondition, branch) FirWhenBranchImpl(entry, firCondition, branch)
} else { } else {
val condition = entry.conditions.first() as? KtWhenConditionWithExpression val condition = entry.conditions.first() as? KtWhenConditionWithExpression
val firCondition = condition?.expression.toFirExpression("No expression in condition with expression") val firCondition = condition?.expression.toFirExpression("No expression in condition with expression")
FirWhenBranchImpl(this@RawFirBuilder.session, entry, firCondition, branch) FirWhenBranchImpl(entry, firCondition, branch)
} }
} else { } else {
FirWhenBranchImpl( FirWhenBranchImpl(entry, FirElseIfTrueCondition(null), branch)
this@RawFirBuilder.session, entry, FirElseIfTrueCondition(this@RawFirBuilder.session, null), branch
)
} }
} }
} }
@@ -1075,52 +1048,52 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {
override fun visitDoWhileExpression(expression: KtDoWhileExpression, data: Unit): FirElement { override fun visitDoWhileExpression(expression: KtDoWhileExpression, data: Unit): FirElement {
return FirDoWhileLoopImpl( return FirDoWhileLoopImpl(
session, expression, expression.condition.toFirExpression("No condition in do-while loop") expression, expression.condition.toFirExpression("No condition in do-while loop")
).configure { expression.body.toFirBlock() } ).configure { expression.body.toFirBlock() }
} }
override fun visitWhileExpression(expression: KtWhileExpression, data: Unit): FirElement { override fun visitWhileExpression(expression: KtWhileExpression, data: Unit): FirElement {
return FirWhileLoopImpl( return FirWhileLoopImpl(
session, expression, expression.condition.toFirExpression("No condition in while loop") expression, expression.condition.toFirExpression("No condition in while loop")
).configure { expression.body.toFirBlock() } ).configure { expression.body.toFirBlock() }
} }
override fun visitForExpression(expression: KtForExpression, data: Unit?): FirElement { override fun visitForExpression(expression: KtForExpression, data: Unit?): FirElement {
val rangeExpression = expression.loopRange.toFirExpression("No range in for loop") val rangeExpression = expression.loopRange.toFirExpression("No range in for loop")
val parameter = expression.loopParameter val parameter = expression.loopParameter
return FirBlockImpl(session, expression).apply { return FirBlockImpl(expression).apply {
val rangeVal = val rangeVal =
generateTemporaryVariable(this@RawFirBuilder.session, expression.loopRange, Name.special("<range>"), rangeExpression) generateTemporaryVariable(this@RawFirBuilder.session, expression.loopRange, Name.special("<range>"), rangeExpression)
statements += rangeVal statements += rangeVal
val iteratorVal = generateTemporaryVariable( val iteratorVal = generateTemporaryVariable(
this@RawFirBuilder.session, expression.loopRange, Name.special("<iterator>"), this@RawFirBuilder.session, expression.loopRange, Name.special("<iterator>"),
FirFunctionCallImpl(this@RawFirBuilder.session, expression).apply { FirFunctionCallImpl(expression).apply {
calleeReference = FirSimpleNamedReference(this@RawFirBuilder.session, expression, Name.identifier("iterator")) calleeReference = FirSimpleNamedReference(expression, Name.identifier("iterator"))
explicitReceiver = generateResolvedAccessExpression(this@RawFirBuilder.session, expression.loopRange, rangeVal) explicitReceiver = generateResolvedAccessExpression(expression.loopRange, rangeVal)
} }
) )
statements += iteratorVal statements += iteratorVal
statements += FirWhileLoopImpl( statements += FirWhileLoopImpl(
this@RawFirBuilder.session, expression, expression,
FirFunctionCallImpl(this@RawFirBuilder.session, expression).apply { FirFunctionCallImpl(expression).apply {
calleeReference = FirSimpleNamedReference(this@RawFirBuilder.session, expression, Name.identifier("hasNext")) calleeReference = FirSimpleNamedReference(expression, Name.identifier("hasNext"))
explicitReceiver = generateResolvedAccessExpression(this@RawFirBuilder.session, expression, iteratorVal) explicitReceiver = generateResolvedAccessExpression(expression, iteratorVal)
} }
).configure { ).configure {
// NB: just body.toFirBlock() isn't acceptable here because we need to add some statements // NB: just body.toFirBlock() isn't acceptable here because we need to add some statements
val block = when (val body = expression.body) { val block = when (val body = expression.body) {
is KtBlockExpression -> body.accept(this@Visitor, Unit) as FirBlockImpl is KtBlockExpression -> body.accept(this@Visitor, Unit) as FirBlockImpl
null -> FirBlockImpl(this@RawFirBuilder.session, body) null -> FirBlockImpl(body)
else -> FirBlockImpl(this@RawFirBuilder.session, body).apply { statements += body.toFirStatement() } else -> FirBlockImpl(body).apply { statements += body.toFirStatement() }
} }
if (parameter != null) { if (parameter != null) {
val multiDeclaration = parameter.destructuringDeclaration val multiDeclaration = parameter.destructuringDeclaration
val firLoopParameter = generateTemporaryVariable( val firLoopParameter = generateTemporaryVariable(
this@RawFirBuilder.session, expression.loopParameter, this@RawFirBuilder.session, expression.loopParameter,
if (multiDeclaration != null) Name.special("<destruct>") else parameter.nameAsSafeName, if (multiDeclaration != null) Name.special("<destruct>") else parameter.nameAsSafeName,
FirFunctionCallImpl(this@RawFirBuilder.session, expression).apply { FirFunctionCallImpl(expression).apply {
calleeReference = FirSimpleNamedReference(this@RawFirBuilder.session, expression, Name.identifier("next")) calleeReference = FirSimpleNamedReference(expression, Name.identifier("next"))
explicitReceiver = generateResolvedAccessExpression(this@RawFirBuilder.session, expression, iteratorVal) explicitReceiver = generateResolvedAccessExpression(expression, iteratorVal)
} }
) )
if (multiDeclaration != null) { if (multiDeclaration != null) {
@@ -1153,7 +1126,7 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {
if (lastLoop != null) { if (lastLoop != null) {
target.bind(lastLoop) target.bind(lastLoop)
} else { } else {
target.bind(FirErrorLoop(this@RawFirBuilder.session, psi, "Cannot bind unlabeled jump to a loop")) target.bind(FirErrorLoop(psi, "Cannot bind unlabeled jump to a loop"))
} }
} else { } else {
for (firLoop in firLoops.asReversed()) { for (firLoop in firLoops.asReversed()) {
@@ -1162,25 +1135,25 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {
return this return this
} }
} }
target.bind(FirErrorLoop(this@RawFirBuilder.session, psi, "Cannot bind label $labelName to a loop")) target.bind(FirErrorLoop(psi, "Cannot bind label $labelName to a loop"))
} }
return this return this
} }
override fun visitBreakExpression(expression: KtBreakExpression, data: Unit): FirElement { override fun visitBreakExpression(expression: KtBreakExpression, data: Unit): FirElement {
return FirBreakExpressionImpl(session, expression).bindLabel(expression) return FirBreakExpressionImpl(expression).bindLabel(expression)
} }
override fun visitContinueExpression(expression: KtContinueExpression, data: Unit): FirElement { override fun visitContinueExpression(expression: KtContinueExpression, data: Unit): FirElement {
return FirContinueExpressionImpl(session, expression).bindLabel(expression) return FirContinueExpressionImpl(expression).bindLabel(expression)
} }
private fun KtUnaryExpression.bangBangToWhen(): FirWhenExpression { private fun KtUnaryExpression.bangBangToWhen(): FirWhenExpression {
return baseExpression.toFirExpression("No operand").generateNotNullOrOther( return baseExpression.toFirExpression("No operand").generateNotNullOrOther(
session, session,
FirThrowExpressionImpl( FirThrowExpressionImpl(
session, this, FirFunctionCallImpl(session, this).apply { this, FirFunctionCallImpl(this).apply {
calleeReference = FirSimpleNamedReference(this@RawFirBuilder.session, this@bangBangToWhen, KNPE) calleeReference = FirSimpleNamedReference(this@bangBangToWhen, KNPE)
} }
), "bangbang", this ), "bangbang", this
) )
@@ -1194,19 +1167,17 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {
ELVIS -> ELVIS ->
return leftArgument.generateNotNullOrOther(session, rightArgument, "elvis", expression) return leftArgument.generateNotNullOrOther(session, rightArgument, "elvis", expression)
ANDAND, OROR -> ANDAND, OROR ->
return leftArgument.generateLazyLogicalOperation(session, rightArgument, operationToken == ANDAND, expression) return leftArgument.generateLazyLogicalOperation(rightArgument, operationToken == ANDAND, expression)
in OperatorConventions.IN_OPERATIONS -> in OperatorConventions.IN_OPERATIONS ->
return rightArgument.generateContainsOperation( return rightArgument.generateContainsOperation(
session, leftArgument, operationToken == NOT_IN, expression, expression.operationReference leftArgument, operationToken == NOT_IN, expression, expression.operationReference
) )
} }
val conventionCallName = operationToken.toBinaryName() val conventionCallName = operationToken.toBinaryName()
return if (conventionCallName != null || operationToken == IDENTIFIER) { return if (conventionCallName != null || operationToken == IDENTIFIER) {
FirFunctionCallImpl( FirFunctionCallImpl(expression).apply {
session, expression
).apply {
calleeReference = FirSimpleNamedReference( calleeReference = FirSimpleNamedReference(
this@RawFirBuilder.session, expression.operationReference, expression.operationReference,
conventionCallName ?: expression.operationReference.getReferencedNameAsName() conventionCallName ?: expression.operationReference.getReferencedNameAsName()
) )
explicitReceiver = leftArgument explicitReceiver = leftArgument
@@ -1219,7 +1190,7 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {
toFirExpression("Incorrect expression in assignment: ${expression.text}") toFirExpression("Incorrect expression in assignment: ${expression.text}")
} }
} else { } else {
FirOperatorCallImpl(session, expression, firOperation).apply { FirOperatorCallImpl(expression, firOperation).apply {
arguments += leftArgument arguments += leftArgument
arguments += rightArgument arguments += rightArgument
} }
@@ -1230,7 +1201,7 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {
override fun visitBinaryWithTypeRHSExpression(expression: KtBinaryExpressionWithTypeRHS, data: Unit): FirElement { override fun visitBinaryWithTypeRHSExpression(expression: KtBinaryExpressionWithTypeRHS, data: Unit): FirElement {
val operation = expression.operationReference.getReferencedNameElementType().toFirOperation() val operation = expression.operationReference.getReferencedNameElementType().toFirOperation()
return FirTypeOperatorCallImpl( return FirTypeOperatorCallImpl(
session, expression, operation, expression.right.toFirOrErrorType() expression, operation, expression.right.toFirOrErrorType()
).apply { ).apply {
arguments += expression.left.toFirExpression("No left operand") arguments += expression.left.toFirExpression("No left operand")
} }
@@ -1238,7 +1209,7 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {
override fun visitIsExpression(expression: KtIsExpression, data: Unit): FirElement { override fun visitIsExpression(expression: KtIsExpression, data: Unit): FirElement {
return FirTypeOperatorCallImpl( return FirTypeOperatorCallImpl(
session, expression, if (expression.isNegated) FirOperation.NOT_IS else FirOperation.IS, expression, if (expression.isNegated) FirOperation.NOT_IS else FirOperation.IS,
expression.typeReference.toFirOrErrorType() expression.typeReference.toFirOrErrorType()
).apply { ).apply {
arguments += expression.leftHandSide.toFirExpression("No left operand") arguments += expression.leftHandSide.toFirExpression("No left operand")
@@ -1260,19 +1231,15 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {
prefix = expression is KtPrefixExpression prefix = expression is KtPrefixExpression
) { toFirExpression("Incorrect expression inside inc/dec") } ) { toFirExpression("Incorrect expression inside inc/dec") }
} }
FirFunctionCallImpl( FirFunctionCallImpl(expression).apply {
session, expression
).apply {
calleeReference = FirSimpleNamedReference( calleeReference = FirSimpleNamedReference(
this@RawFirBuilder.session, expression.operationReference, conventionCallName expression.operationReference, conventionCallName
) )
explicitReceiver = argument.toFirExpression("No operand") explicitReceiver = argument.toFirExpression("No operand")
} }
} else { } else {
val firOperation = operationToken.toFirOperation() val firOperation = operationToken.toFirOperation()
FirOperatorCallImpl( FirOperatorCallImpl(expression, firOperation).apply {
session, expression, firOperation
).apply {
arguments += argument.toFirExpression("No operand") arguments += argument.toFirExpression("No operand")
} }
} }
@@ -1282,18 +1249,18 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {
override fun visitCallExpression(expression: KtCallExpression, data: Unit): FirElement { override fun visitCallExpression(expression: KtCallExpression, data: Unit): FirElement {
val calleeExpression = expression.calleeExpression val calleeExpression = expression.calleeExpression
return FirFunctionCallImpl(session, expression).apply { return FirFunctionCallImpl(expression).apply {
val calleeReference = when (calleeExpression) { val calleeReference = when (calleeExpression) {
is KtSimpleNameExpression -> FirSimpleNamedReference( is KtSimpleNameExpression -> FirSimpleNamedReference(
this@RawFirBuilder.session, calleeExpression, calleeExpression.getReferencedNameAsName() calleeExpression, calleeExpression.getReferencedNameAsName()
) )
null -> FirErrorNamedReference( null -> FirErrorNamedReference(
this@RawFirBuilder.session, calleeExpression, "Call has no callee" calleeExpression, "Call has no callee"
) )
else -> { else -> {
arguments += calleeExpression.toFirExpression("Incorrect invoke receiver") arguments += calleeExpression.toFirExpression("Incorrect invoke receiver")
FirSimpleNamedReference( FirSimpleNamedReference(
this@RawFirBuilder.session, expression, OperatorNameConventions.INVOKE expression, OperatorNameConventions.INVOKE
) )
} }
} }
@@ -1309,8 +1276,8 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {
override fun visitArrayAccessExpression(expression: KtArrayAccessExpression, data: Unit): FirElement { override fun visitArrayAccessExpression(expression: KtArrayAccessExpression, data: Unit): FirElement {
val arrayExpression = expression.arrayExpression val arrayExpression = expression.arrayExpression
return FirFunctionCallImpl(session, expression).apply { return FirFunctionCallImpl(expression).apply {
calleeReference = FirSimpleNamedReference(this@RawFirBuilder.session, expression, OperatorNameConventions.GET) calleeReference = FirSimpleNamedReference(expression, OperatorNameConventions.GET)
explicitReceiver = arrayExpression.toFirExpression("No array expression") explicitReceiver = arrayExpression.toFirExpression("No array expression")
for (indexExpression in expression.indexExpressions) { for (indexExpression in expression.indexExpressions) {
arguments += indexExpression.toFirExpression("Incorrect index expression") arguments += indexExpression.toFirExpression("Incorrect index expression")
@@ -1320,7 +1287,7 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {
override fun visitQualifiedExpression(expression: KtQualifiedExpression, data: Unit): FirElement { override fun visitQualifiedExpression(expression: KtQualifiedExpression, data: Unit): FirElement {
val selector = expression.selectorExpression val selector = expression.selectorExpression
?: return FirErrorExpressionImpl(session, expression, "Qualified expression without selector") ?: return FirErrorExpressionImpl(expression, "Qualified expression without selector")
val firSelector = selector.toFirExpression("Incorrect selector expression") val firSelector = selector.toFirExpression("Incorrect selector expression")
if (firSelector is FirModifiableQualifiedAccess<*>) { if (firSelector is FirModifiableQualifiedAccess<*>) {
firSelector.safe = expression is KtSafeQualifiedExpression firSelector.safe = expression is KtSafeQualifiedExpression
@@ -1331,20 +1298,20 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {
override fun visitThisExpression(expression: KtThisExpression, data: Unit): FirElement { override fun visitThisExpression(expression: KtThisExpression, data: Unit): FirElement {
val labelName = expression.getLabelName() val labelName = expression.getLabelName()
return FirQualifiedAccessExpressionImpl(session, expression).apply { return FirQualifiedAccessExpressionImpl(expression).apply {
calleeReference = FirExplicitThisReference(this@RawFirBuilder.session, expression, labelName) calleeReference = FirExplicitThisReference(expression, labelName)
} }
} }
override fun visitSuperExpression(expression: KtSuperExpression, data: Unit): FirElement { override fun visitSuperExpression(expression: KtSuperExpression, data: Unit): FirElement {
val superType = expression.superTypeQualifier val superType = expression.superTypeQualifier
return FirQualifiedAccessExpressionImpl(session, expression).apply { return FirQualifiedAccessExpressionImpl(expression).apply {
calleeReference = FirExplicitSuperReference(this@RawFirBuilder.session, expression, superType.toFirOrImplicitType()) calleeReference = FirExplicitSuperReference(expression, superType.toFirOrImplicitType())
} }
} }
override fun visitParenthesizedExpression(expression: KtParenthesizedExpression, data: Unit): FirElement { override fun visitParenthesizedExpression(expression: KtParenthesizedExpression, data: Unit): FirElement {
return expression.expression?.accept(this, data) ?: FirErrorExpressionImpl(session, expression, "Empty parentheses") return expression.expression?.accept(this, data) ?: FirErrorExpressionImpl(expression, "Empty parentheses")
} }
private val firLabels = mutableListOf<FirLabel>() private val firLabels = mutableListOf<FirLabel>()
@@ -1353,9 +1320,9 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {
val labelName = expression.getLabelName() val labelName = expression.getLabelName()
val size = firLabels.size val size = firLabels.size
if (labelName != null) { if (labelName != null) {
firLabels += FirLabelImpl(session, expression, labelName) firLabels += FirLabelImpl(expression, labelName)
} }
val result = expression.baseExpression?.accept(this, data) ?: FirErrorExpressionImpl(session, expression, "Empty label") val result = expression.baseExpression?.accept(this, data) ?: FirErrorExpressionImpl(expression, "Empty label")
if (size != firLabels.size) { if (size != firLabels.size) {
firLabels.removeLast() firLabels.removeLast()
println("Unused label: ${expression.text}") println("Unused label: ${expression.text}")
@@ -1366,13 +1333,13 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {
override fun visitAnnotatedExpression(expression: KtAnnotatedExpression, data: Unit): FirElement { override fun visitAnnotatedExpression(expression: KtAnnotatedExpression, data: Unit): FirElement {
val rawResult = expression.baseExpression?.accept(this, data) val rawResult = expression.baseExpression?.accept(this, data)
val result = rawResult as? FirAbstractAnnotatedElement val result = rawResult as? FirAbstractAnnotatedElement
?: FirErrorExpressionImpl(session, expression, "Strange annotated expression: ${rawResult?.render()}") ?: FirErrorExpressionImpl(expression, "Strange annotated expression: ${rawResult?.render()}")
expression.extractAnnotationsTo(result) expression.extractAnnotationsTo(result)
return result return result
} }
override fun visitThrowExpression(expression: KtThrowExpression, data: Unit): FirElement { override fun visitThrowExpression(expression: KtThrowExpression, data: Unit): FirElement {
return FirThrowExpressionImpl(session, expression, expression.thrownExpression.toFirExpression("Nothing to throw")) return FirThrowExpressionImpl(expression, expression.thrownExpression.toFirExpression("Nothing to throw"))
} }
override fun visitDestructuringDeclaration(multiDeclaration: KtDestructuringDeclaration, data: Unit): FirElement { override fun visitDestructuringDeclaration(multiDeclaration: KtDestructuringDeclaration, data: Unit): FirElement {
@@ -1392,22 +1359,22 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {
} }
override fun visitClassLiteralExpression(expression: KtClassLiteralExpression, data: Unit): FirElement { override fun visitClassLiteralExpression(expression: KtClassLiteralExpression, data: Unit): FirElement {
return FirGetClassCallImpl(session, expression).apply { return FirGetClassCallImpl(expression).apply {
arguments += expression.receiverExpression.toFirExpression("No receiver in class literal") arguments += expression.receiverExpression.toFirExpression("No receiver in class literal")
} }
} }
override fun visitCallableReferenceExpression(expression: KtCallableReferenceExpression, data: Unit): FirElement { override fun visitCallableReferenceExpression(expression: KtCallableReferenceExpression, data: Unit): FirElement {
return FirCallableReferenceAccessImpl(session, expression).apply { return FirCallableReferenceAccessImpl(expression).apply {
calleeReference = FirSimpleNamedReference( calleeReference = FirSimpleNamedReference(
this@RawFirBuilder.session, expression.callableReference, expression.callableReference.getReferencedNameAsName() expression.callableReference, expression.callableReference.getReferencedNameAsName()
) )
explicitReceiver = expression.receiverExpression?.toFirExpression("Incorrect receiver expression") explicitReceiver = expression.receiverExpression?.toFirExpression("Incorrect receiver expression")
} }
} }
override fun visitCollectionLiteralExpression(expression: KtCollectionLiteralExpression, data: Unit): FirElement { override fun visitCollectionLiteralExpression(expression: KtCollectionLiteralExpression, data: Unit): FirElement {
return FirArrayOfCallImpl(session, expression).apply { return FirArrayOfCallImpl(expression).apply {
for (innerExpression in expression.getInnerExpressions()) { for (innerExpression in expression.getInnerExpressions()) {
arguments += innerExpression.toFirExpression("Incorrect collection literal argument") arguments += innerExpression.toFirExpression("Incorrect collection literal argument")
} }
@@ -1415,7 +1382,7 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {
} }
override fun visitExpression(expression: KtExpression, data: Unit): FirElement { override fun visitExpression(expression: KtExpression, data: Unit): FirElement {
return FirExpressionStub(session, expression) return FirExpressionStub(expression)
} }
} }
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/CopyUtils.kt
+2 -7
View File
@@ -29,13 +29,10 @@ fun FirFunctionCall.copy(
explicitReceiver: FirExpression? = this.explicitReceiver, explicitReceiver: FirExpression? = this.explicitReceiver,
psi: PsiElement? = this.psi, psi: PsiElement? = this.psi,
safe: Boolean = this.safe, safe: Boolean = this.safe,
session: FirSession = this.session,
typeArguments: List<FirTypeProjection> = this.typeArguments, typeArguments: List<FirTypeProjection> = this.typeArguments,
resultType: FirTypeRef = this.typeRef resultType: FirTypeRef = this.typeRef
): FirFunctionCall { ): FirFunctionCall {
return FirFunctionCallImpl( return FirFunctionCallImpl(psi, safe).apply {
session, psi, safe
).apply {
this.annotations.addAll(annotations) this.annotations.addAll(annotations)
this.arguments.addAll(arguments) this.arguments.addAll(arguments)
this.calleeReference = calleeReference this.calleeReference = calleeReference
@@ -69,9 +66,7 @@ fun FirAnonymousFunction.copy(
fun FirTypeRef.resolvedTypeFromPrototype( fun FirTypeRef.resolvedTypeFromPrototype(
type: ConeKotlinType type: ConeKotlinType
): FirResolvedTypeRef { ): FirResolvedTypeRef {
return FirResolvedTypeRefImpl( return FirResolvedTypeRefImpl(psi, type, annotations)
session, psi, type, annotations
)
} }
fun FirTypeParameter.copy( fun FirTypeParameter.copy(
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirCallResolver.kt
+7 -8
View File
@@ -188,7 +188,7 @@ class FirCallResolver(
else -> null else -> null
} }
if (referencedSymbol is ConeClassLikeSymbol) { if (referencedSymbol is ConeClassLikeSymbol) {
return FirResolvedQualifierImpl(session, nameReference.psi, referencedSymbol.classId).apply { return FirResolvedQualifierImpl(nameReference.psi, referencedSymbol.classId).apply {
resultType = typeForQualifier(this) resultType = typeForQualifier(this)
} }
} }
@@ -209,15 +209,14 @@ class FirCallResolver(
applicability: CandidateApplicability applicability: CandidateApplicability
): FirNamedReference { ): FirNamedReference {
val name = namedReference.name val name = namedReference.name
val firSession = namedReference.session
val psi = namedReference.psi val psi = namedReference.psi
return when { return when {
candidates.isEmpty() -> FirErrorNamedReference( candidates.isEmpty() -> FirErrorNamedReference(
firSession, psi, "Unresolved name: $name" psi, "Unresolved name: $name"
) )
applicability < CandidateApplicability.SYNTHETIC_RESOLVED -> { applicability < CandidateApplicability.SYNTHETIC_RESOLVED -> {
FirErrorNamedReference( FirErrorNamedReference(
firSession, psi, psi,
"Inapplicable($applicability): ${candidates.map { describeSymbol(it.symbol) }}", "Inapplicable($applicability): ${candidates.map { describeSymbol(it.symbol) }}",
namedReference.name namedReference.name
) )
@@ -226,15 +225,15 @@ class FirCallResolver(
val candidate = candidates.single() val candidate = candidates.single()
val coneSymbol = candidate.symbol val coneSymbol = candidate.symbol
when { when {
coneSymbol is FirBackingFieldSymbol -> FirBackingFieldReferenceImpl(firSession, psi, coneSymbol) coneSymbol is FirBackingFieldSymbol -> FirBackingFieldReferenceImpl(psi, coneSymbol)
coneSymbol is FirVariableSymbol && coneSymbol is FirVariableSymbol &&
(coneSymbol !is FirPropertySymbol || coneSymbol.firUnsafe<FirMemberDeclaration>().typeParameters.isEmpty()) -> (coneSymbol !is FirPropertySymbol || coneSymbol.firUnsafe<FirMemberDeclaration>().typeParameters.isEmpty()) ->
FirResolvedCallableReferenceImpl(firSession, psi, name, coneSymbol) FirResolvedCallableReferenceImpl(psi, name, coneSymbol)
else -> FirNamedReferenceWithCandidate(firSession, psi, name, candidate) else -> FirNamedReferenceWithCandidate(psi, name, candidate)
} }
} }
else -> FirErrorNamedReference( else -> FirErrorNamedReference(
firSession, psi, "Ambiguity: $name, ${candidates.map { describeSymbol(it.symbol) }}", psi, "Ambiguity: $name, ${candidates.map { describeSymbol(it.symbol) }}",
namedReference.name namedReference.name
) )
} }
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirQualifiedNameResolver.kt
+1 -3
View File
@@ -58,12 +58,10 @@ class FirQualifiedNameResolver(components: BodyResolveComponents) : BodyResolveC
if (resolved != null) { if (resolved != null) {
qualifierPartsToDrop = qualifierParts.size - 1 qualifierPartsToDrop = qualifierParts.size - 1
return FirResolvedQualifierImpl( return FirResolvedQualifierImpl(
session,
null /* TODO */, null /* TODO */,
resolved.packageFqName, resolved.packageFqName,
resolved.relativeClassFqName resolved.relativeClassFqName
) ).apply { resultType = typeForQualifier(this) }
.apply { resultType = typeForQualifier(this) }
} }
return null return null
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/deserialization/AbstractAnnotationDeserializer.kt
+11 -13
View File
@@ -83,19 +83,19 @@ abstract class AbstractAnnotationDeserializer(
val parameter = parameterByName[name] ?: return@mapNotNull null val parameter = parameterByName[name] ?: return@mapNotNull null
val value = resolveValue(parameter.returnTypeRef, it.value, nameResolver) ?: return@mapNotNull null val value = resolveValue(parameter.returnTypeRef, it.value, nameResolver) ?: return@mapNotNull null
FirNamedArgumentExpressionImpl( FirNamedArgumentExpressionImpl(
session, null, name, false, value null, name, false, value
) )
} }
} }
} }
return FirAnnotationCallImpl( return FirAnnotationCallImpl(
session, null, null, null, null,
symbol?.let { symbol?.let {
FirResolvedTypeRefImpl( FirResolvedTypeRefImpl(
session, null, it.constructType(emptyList(), isNullable = false) null, it.constructType(emptyList(), isNullable = false)
) )
} ?: FirErrorTypeRefImpl(session, null, "Symbol not found for $classId") } ?: FirErrorTypeRefImpl(null, "Symbol not found for $classId")
).apply { ).apply {
this.arguments += arguments this.arguments += arguments
} }
@@ -117,27 +117,25 @@ abstract class AbstractAnnotationDeserializer(
BOOLEAN -> const(IrConstKind.Boolean, (value.intValue != 0L)) BOOLEAN -> const(IrConstKind.Boolean, (value.intValue != 0L))
STRING -> const(IrConstKind.String, nameResolver.getString(value.stringValue)) STRING -> const(IrConstKind.String, nameResolver.getString(value.stringValue))
ANNOTATION -> deserializeAnnotation(value.annotation, nameResolver) ANNOTATION -> deserializeAnnotation(value.annotation, nameResolver)
CLASS -> FirGetClassCallImpl(session, null).apply { CLASS -> FirGetClassCallImpl(null).apply {
val classId = nameResolver.getClassId(value.classId) val classId = nameResolver.getClassId(value.classId)
val lookupTag = ConeClassLikeLookupTagImpl(classId) val lookupTag = ConeClassLikeLookupTagImpl(classId)
val referencedType = lookupTag.constructType(emptyArray(), isNullable = false) val referencedType = lookupTag.constructType(emptyArray(), isNullable = false)
arguments += FirClassReferenceExpressionImpl( arguments += FirClassReferenceExpressionImpl(
this@AbstractAnnotationDeserializer.session, null, null,
FirResolvedTypeRefImpl( FirResolvedTypeRefImpl(null, referencedType)
this@AbstractAnnotationDeserializer.session, null, referencedType
)
) )
} }
ENUM -> FirFunctionCallImpl(session, null).apply { ENUM -> FirFunctionCallImpl(null).apply {
val classId = nameResolver.getClassId(value.classId) val classId = nameResolver.getClassId(value.classId)
val entryName = nameResolver.getName(value.enumValueId) val entryName = nameResolver.getName(value.enumValueId)
val entryClassId = classId.createNestedClassId(entryName) val entryClassId = classId.createNestedClassId(entryName)
val entryLookupTag = ConeClassLikeLookupTagImpl(entryClassId) val entryLookupTag = ConeClassLikeLookupTagImpl(entryClassId)
val entrySymbol = entryLookupTag.toSymbol(this@AbstractAnnotationDeserializer.session) val entrySymbol = entryLookupTag.toSymbol(this@AbstractAnnotationDeserializer.session)
this.calleeReference = entrySymbol?.let { this.calleeReference = entrySymbol?.let {
FirResolvedCallableReferenceImpl(this@AbstractAnnotationDeserializer.session, null, entryName, it) FirResolvedCallableReferenceImpl(null, entryName, it)
} ?: FirErrorNamedReference( } ?: FirErrorNamedReference(
this@AbstractAnnotationDeserializer.session, null, null,
errorReason = "Strange deserialized enum value: $classId.$entryName" errorReason = "Strange deserialized enum value: $classId.$entryName"
) )
} }
@@ -150,5 +148,5 @@ abstract class AbstractAnnotationDeserializer(
return result return result
} }
private fun <T> const(kind: IrConstKind<T>, value: T) = FirConstExpressionImpl(session, null, kind, value) private fun <T> const(kind: IrConstKind<T>, value: T) = FirConstExpressionImpl(null, kind, value)
} }
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/deserialization/ClassDeserialization.kt
+1 -2
View File
@@ -68,7 +68,7 @@ fun deserializeClassToSymbol(
superTypesDeserialized.mapNotNullTo(superTypeRefs) { superTypesDeserialized.mapNotNullTo(superTypeRefs) {
if (it == null) return@mapNotNullTo null if (it == null) return@mapNotNullTo null
FirResolvedTypeRefImpl(session, null, it) FirResolvedTypeRefImpl(null, it)
} }
addDeclarations(classProto.functionList.map(classDeserializer::loadFunction)) addDeclarations(classProto.functionList.map(classDeserializer::loadFunction))
@@ -95,7 +95,6 @@ fun deserializeClassToSymbol(
val symbol = FirClassSymbol(enumEntryId) val symbol = FirClassSymbol(enumEntryId)
FirEnumEntryImpl(session, null, symbol, enumEntryId.shortClassName).apply { FirEnumEntryImpl(session, null, symbol, enumEntryId.shortClassName).apply {
superTypeRefs += FirResolvedTypeRefImpl( superTypeRefs += FirResolvedTypeRefImpl(
session,
null, null,
ConeClassTypeImpl(ConeClassLikeLookupTagImpl(classId), emptyArray(), false), ConeClassTypeImpl(ConeClassLikeLookupTagImpl(classId), emptyArray(), false),
emptyList() emptyList()
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/deserialization/FirMemberDeserializer.kt
+2 -4
View File
@@ -136,7 +136,6 @@ class FirMemberDeserializer(private val c: FirDeserializationContext) {
Flags.IS_EXPECT_CLASS.get(flags), Flags.IS_EXPECT_CLASS.get(flags),
false, false,
FirResolvedTypeRefImpl( FirResolvedTypeRefImpl(
c.session,
null, null,
local.typeDeserializer.type(proto.underlyingType(c.typeTable)), local.typeDeserializer.type(proto.underlyingType(c.typeTable)),
emptyList() /* TODO */ emptyList() /* TODO */
@@ -239,7 +238,6 @@ class FirMemberDeserializer(private val c: FirDeserializationContext) {
} }
val delegatedSelfType = FirResolvedTypeRefImpl( val delegatedSelfType = FirResolvedTypeRefImpl(
c.session,
null, null,
ConeClassTypeImpl( ConeClassTypeImpl(
klass.symbol.toLookupTag(), klass.symbol.toLookupTag(),
@@ -280,7 +278,7 @@ class FirMemberDeserializer(private val c: FirDeserializationContext) {
private fun defaultValue(flags: Int): FirExpression? { private fun defaultValue(flags: Int): FirExpression? {
if (Flags.DECLARES_DEFAULT_VALUE.get(flags)) { if (Flags.DECLARES_DEFAULT_VALUE.get(flags)) {
return FirExpressionStub(c.session, null) return FirExpressionStub(null)
} }
return null return null
} }
@@ -306,7 +304,7 @@ class FirMemberDeserializer(private val c: FirDeserializationContext) {
private fun ProtoBuf.Type.toTypeRef(context: FirDeserializationContext): FirTypeRef { private fun ProtoBuf.Type.toTypeRef(context: FirDeserializationContext): FirTypeRef {
val coneType = context.typeDeserializer.type(this) val coneType = context.typeDeserializer.type(this)
return FirResolvedTypeRefImpl( return FirResolvedTypeRefImpl(
context.session, null, coneType, null, coneType,
context.annotationDeserializer.loadTypeAnnotations(this, context.nameResolver) context.annotationDeserializer.loadTypeAnnotations(this, context.nameResolver)
) )
} }
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/deserialization/FirTypeDeserializer.kt
+1 -1
View File
@@ -96,7 +96,7 @@ class FirTypeDeserializer(
val declaration = symbol.fir as FirTypeParameterImpl val declaration = symbol.fir as FirTypeParameterImpl
declaration.apply { declaration.apply {
proto.upperBoundList.mapTo(bounds) { proto.upperBoundList.mapTo(bounds) {
FirResolvedTypeRefImpl(session, null, type(it), emptyList()) FirResolvedTypeRefImpl(null, type(it), emptyList())
} }
} }
} }
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ResolveUtils.kt
+4 -6
View File
@@ -169,7 +169,7 @@ fun FirFunction.constructFunctionalTypeRef(session: FirSession): FirResolvedType
val functionalTypeId = StandardClassIds.byName("Function${receiverAndParameterTypes.size - 1}") val functionalTypeId = StandardClassIds.byName("Function${receiverAndParameterTypes.size - 1}")
val functionalType = functionalTypeId(session.service()).constructType(receiverAndParameterTypes.toTypedArray(), isNullable = false) val functionalType = functionalTypeId(session.service()).constructType(receiverAndParameterTypes.toTypedArray(), isNullable = false)
return FirResolvedTypeRefImpl(session, psi, functionalType) return FirResolvedTypeRefImpl(psi, functionalType)
} }
fun BodyResolveComponents.typeForQualifier(resolvedQualifier: FirResolvedQualifier): FirTypeRef { fun BodyResolveComponents.typeForQualifier(resolvedQualifier: FirResolvedQualifier): FirTypeRef {
@@ -214,7 +214,7 @@ fun <T : FirQualifiedAccess> BodyResolveComponents.typeFromCallee(access: T): Fi
return when (val newCallee = access.calleeReference) { return when (val newCallee = access.calleeReference) {
is FirErrorNamedReference -> is FirErrorNamedReference ->
FirErrorTypeRefImpl(session, access.psi, newCallee.errorReason) FirErrorTypeRefImpl(access.psi, newCallee.errorReason)
is FirNamedReferenceWithCandidate -> { is FirNamedReferenceWithCandidate -> {
typeFromSymbol(newCallee.candidateSymbol, makeNullable) typeFromSymbol(newCallee.candidateSymbol, makeNullable)
} }
@@ -225,7 +225,7 @@ fun <T : FirQualifiedAccess> BodyResolveComponents.typeFromCallee(access: T): Fi
val labelName = newCallee.labelName val labelName = newCallee.labelName
val types = if (labelName == null) labels.values() else labels[Name.identifier(labelName)] val types = if (labelName == null) labels.values() else labels[Name.identifier(labelName)]
val type = types.lastOrNull() ?: ConeKotlinErrorType("Unresolved this@$labelName") val type = types.lastOrNull() ?: ConeKotlinErrorType("Unresolved this@$labelName")
FirResolvedTypeRefImpl(session, null, type, emptyList()) FirResolvedTypeRefImpl(null, type, emptyList())
} }
else -> error("Failed to extract type from: $newCallee") else -> error("Failed to extract type from: $newCallee")
} }
@@ -237,7 +237,6 @@ private fun BodyResolveComponents.typeFromSymbol(symbol: ConeSymbol, makeNullabl
val returnType = returnTypeCalculator.tryCalculateReturnType(symbol.fir) val returnType = returnTypeCalculator.tryCalculateReturnType(symbol.fir)
if (makeNullable) { if (makeNullable) {
returnType.withReplacedConeType( returnType.withReplacedConeType(
session,
returnType.coneTypeUnsafe<ConeKotlinType>().withNullability(ConeNullability.NULLABLE) returnType.coneTypeUnsafe<ConeKotlinType>().withNullability(ConeNullability.NULLABLE)
) )
} else { } else {
@@ -249,13 +248,12 @@ private fun BodyResolveComponents.typeFromSymbol(symbol: ConeSymbol, makeNullabl
// TODO: unhack // TODO: unhack
if (fir is FirEnumEntry) { if (fir is FirEnumEntry) {
(fir.superTypeRefs.firstOrNull() as? FirResolvedTypeRef) ?: FirErrorTypeRefImpl( (fir.superTypeRefs.firstOrNull() as? FirResolvedTypeRef) ?: FirErrorTypeRefImpl(
session,
null, null,
"no enum item supertype" "no enum item supertype"
) )
} else } else
FirResolvedTypeRefImpl( FirResolvedTypeRefImpl(
session, null, symbol.constructType(emptyArray(), isNullable = false), null, symbol.constructType(emptyArray(), isNullable = false),
annotations = emptyList() annotations = emptyList()
) )
} }
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/CandidateCollector.kt
+1 -2
View File
@@ -82,9 +82,8 @@ class InvokeReceiverCandidateCollector(
val session = components.session val session = components.session
val boundInvokeCallInfo = CallInfo( val boundInvokeCallInfo = CallInfo(
invokeCallInfo.callKind, invokeCallInfo.callKind,
FirQualifiedAccessExpressionImpl(session, null, false).apply { FirQualifiedAccessExpressionImpl(null, false).apply {
calleeReference = FirNamedReferenceWithCandidate( calleeReference = FirNamedReferenceWithCandidate(
session,
null, null,
(candidate.symbol as ConeCallableSymbol).callableId.callableName, (candidate.symbol as ConeCallableSymbol).callableId.callableName,
candidate candidate
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/FirNamedReferenceWithCandidate.kt
+5 -3
View File
@@ -6,13 +6,15 @@
package org.jetbrains.kotlin.fir.resolve.calls package org.jetbrains.kotlin.fir.resolve.calls
import com.intellij.psi.PsiElement import com.intellij.psi.PsiElement
import org.jetbrains.kotlin.fir.*
import org.jetbrains.kotlin.fir.references.FirSimpleNamedReference import org.jetbrains.kotlin.fir.references.FirSimpleNamedReference
import org.jetbrains.kotlin.fir.symbols.ConeSymbol import org.jetbrains.kotlin.fir.symbols.ConeSymbol
import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.name.Name
class FirNamedReferenceWithCandidate(session: FirSession, psi: PsiElement?, name: Name, val candidate: Candidate) : class FirNamedReferenceWithCandidate(
FirSimpleNamedReference(session, psi, name) { psi: PsiElement?,
name: Name,
val candidate: Candidate
) : FirSimpleNamedReference(psi, name) {
override val candidateSymbol: ConeSymbol override val candidateSymbol: ConeSymbol
get() = candidate.symbol get() = candidate.symbol
} }
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/TowerLevels.kt
+1 -2
View File
@@ -207,8 +207,7 @@ class QualifiedReceiverTowerLevel(session: FirSession) : SessionBasedTowerLevel(
val scope = FirExplicitSimpleImportingScope( val scope = FirExplicitSimpleImportingScope(
listOf( listOf(
FirResolvedImportImpl( FirResolvedImportImpl(
session, FirImportImpl(null, FqName.topLevel(name), false, null),
FirImportImpl(session, null, FqName.topLevel(name), false, null),
qualifiedReceiver.packageFqName, qualifiedReceiver.packageFqName,
qualifiedReceiver.relativeClassFqName qualifiedReceiver.relativeClassFqName
) )
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/impl/FirLibrarySymbolProviderImpl.kt
+5 -7
View File
@@ -182,7 +182,7 @@ class FirLibrarySymbolProviderImpl(val session: FirSession) : FirSymbolProvider(
).apply klass@{ ).apply klass@{
typeParameters.addAll((1..arity).map { typeParameters.addAll((1..arity).map {
FirTypeParameterImpl( FirTypeParameterImpl(
session, this@FirLibrarySymbolProviderImpl.session,
null, null,
FirTypeParameterSymbol(), FirTypeParameterSymbol(),
Name.identifier("P$it"), Name.identifier("P$it"),
@@ -192,7 +192,7 @@ class FirLibrarySymbolProviderImpl(val session: FirSession) : FirSymbolProvider(
}) })
typeParameters.add( typeParameters.add(
FirTypeParameterImpl( FirTypeParameterImpl(
session, this@FirLibrarySymbolProviderImpl.session,
null, null,
FirTypeParameterSymbol(), FirTypeParameterSymbol(),
Name.identifier("R"), Name.identifier("R"),
@@ -203,7 +203,7 @@ class FirLibrarySymbolProviderImpl(val session: FirSession) : FirSymbolProvider(
val name = OperatorNameConventions.INVOKE val name = OperatorNameConventions.INVOKE
addDeclaration( addDeclaration(
FirMemberFunctionImpl( FirMemberFunctionImpl(
session, this@FirLibrarySymbolProviderImpl.session,
null, null,
FirNamedFunctionSymbol(CallableId(packageFqName, relativeClassName, name)), FirNamedFunctionSymbol(CallableId(packageFqName, relativeClassName, name)),
name, name,
@@ -220,7 +220,6 @@ class FirLibrarySymbolProviderImpl(val session: FirSession) : FirSymbolProvider(
isSuspend = false, isSuspend = false,
receiverTypeRef = null, receiverTypeRef = null,
returnTypeRef = FirResolvedTypeRefImpl( returnTypeRef = FirResolvedTypeRefImpl(
session,
null, null,
ConeTypeParameterTypeImpl( ConeTypeParameterTypeImpl(
typeParameters.last().symbol.toLookupTag(), typeParameters.last().symbol.toLookupTag(),
@@ -230,11 +229,10 @@ class FirLibrarySymbolProviderImpl(val session: FirSession) : FirSymbolProvider(
).apply { ).apply {
valueParameters += this@klass.typeParameters.dropLast(1).map { typeParameter -> valueParameters += this@klass.typeParameters.dropLast(1).map { typeParameter ->
FirValueParameterImpl( FirValueParameterImpl(
session, this@FirLibrarySymbolProviderImpl.session,
null, null,
Name.identifier(typeParameter.name.asString().toLowerCase()), Name.identifier(typeParameter.name.asString().toLowerCase()),
FirResolvedTypeRefImpl( FirResolvedTypeRefImpl(
session,
null, null,
ConeTypeParameterTypeImpl(typeParameter.symbol.toLookupTag(), false) ConeTypeParameterTypeImpl(typeParameter.symbol.toLookupTag(), false)
), ),
@@ -246,7 +244,7 @@ class FirLibrarySymbolProviderImpl(val session: FirSession) : FirSymbolProvider(
} }
} }
) )
replaceSupertypes(listOf(FirImplicitAnyTypeRef(session, null))) replaceSupertypes(listOf(FirImplicitAnyTypeRef(null)))
} }
} }
} }
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/FirCallCompleter.kt
+1 -1
View File
@@ -94,7 +94,7 @@ class FirCallCompleter(
session, session,
null, null,
Name.identifier("it"), Name.identifier("it"),
FirResolvedTypeRefImpl(session, null, parameters.single(), emptyList()), FirResolvedTypeRefImpl(null, parameters.single(), emptyList()),
defaultValue = null, defaultValue = null,
isCrossinline = false, isCrossinline = false,
isNoinline = false, isNoinline = false,
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirBodyResolveTransformer.kt
+16 -21
View File
@@ -48,7 +48,7 @@ open class FirBodyResolveTransformer(
) : FirTransformer<Any?>(), BodyResolveComponents { ) : FirTransformer<Any?>(), BodyResolveComponents {
final override val returnTypeCalculator: ReturnTypeCalculator = ReturnTypeCalculatorWithJump(session, scopeSession) final override val returnTypeCalculator: ReturnTypeCalculator = ReturnTypeCalculatorWithJump(session, scopeSession)
override val labels: SetMultimap<Name, ConeKotlinType> = LinkedHashMultimap.create() override val labels: SetMultimap<Name, ConeKotlinType> = LinkedHashMultimap.create()
override val noExpectedType = FirImplicitTypeRefImpl(session, null) override val noExpectedType = FirImplicitTypeRefImpl(null)
override val symbolProvider = session.service<FirSymbolProvider>() override val symbolProvider = session.service<FirSymbolProvider>()
val scopes = mutableListOf<FirScope>() val scopes = mutableListOf<FirScope>()
@@ -157,7 +157,7 @@ open class FirBodyResolveTransformer(
val notNullCast = super.transformUncheckedNotNullCast(uncheckedNotNullCast, data).single as FirUncheckedNotNullCast val notNullCast = super.transformUncheckedNotNullCast(uncheckedNotNullCast, data).single as FirUncheckedNotNullCast
val resultType = notNullCast.expression.resultType val resultType = notNullCast.expression.resultType
notNullCast.resultType = notNullCast.resultType =
resultType.withReplacedConeType(session, resultType.coneTypeUnsafe<ConeKotlinType>().withNullability(ConeNullability.NOT_NULL)) resultType.withReplacedConeType(resultType.coneTypeUnsafe<ConeKotlinType>().withNullability(ConeNullability.NOT_NULL))
return notNullCast.compose() return notNullCast.compose()
} }
@@ -167,7 +167,6 @@ open class FirBodyResolveTransformer(
when ((resolved as FirTypeOperatorCall).operation) { when ((resolved as FirTypeOperatorCall).operation) {
FirOperation.IS, FirOperation.NOT_IS -> { FirOperation.IS, FirOperation.NOT_IS -> {
resolved.resultType = FirResolvedTypeRefImpl( resolved.resultType = FirResolvedTypeRefImpl(
session,
null, null,
StandardClassIds.Boolean(symbolProvider).constructType(emptyArray(), isNullable = false), StandardClassIds.Boolean(symbolProvider).constructType(emptyArray(), isNullable = false),
emptyList() emptyList()
@@ -179,7 +178,6 @@ open class FirBodyResolveTransformer(
FirOperation.SAFE_AS -> { FirOperation.SAFE_AS -> {
resolved.resultType = resolved.resultType =
resolved.conversionTypeRef.withReplacedConeType( resolved.conversionTypeRef.withReplacedConeType(
session,
resolved.conversionTypeRef.coneTypeUnsafe<ConeKotlinType>().withNullability(ConeNullability.NULLABLE) resolved.conversionTypeRef.coneTypeUnsafe<ConeKotlinType>().withNullability(ConeNullability.NULLABLE)
) )
} }
@@ -198,7 +196,7 @@ open class FirBodyResolveTransformer(
val labelName = callee.labelName val labelName = callee.labelName
val types = if (labelName == null) labels.values() else labels[Name.identifier(labelName)] val types = if (labelName == null) labels.values() else labels[Name.identifier(labelName)]
val type = types.lastOrNull() ?: ConeKotlinErrorType("Unresolved this@$labelName") val type = types.lastOrNull() ?: ConeKotlinErrorType("Unresolved this@$labelName")
qualifiedAccessExpression.resultType = FirResolvedTypeRefImpl(session, null, type, emptyList()) qualifiedAccessExpression.resultType = FirResolvedTypeRefImpl(null, type, emptyList())
return qualifiedAccessExpression.compose() return qualifiedAccessExpression.compose()
} }
is FirSuperReference -> { is FirSuperReference -> {
@@ -207,7 +205,7 @@ open class FirBodyResolveTransformer(
} else { } else {
val superTypeRef = implicitReceiverStack.filterIsInstance<ImplicitDispatchReceiverValue>().lastOrNull() val superTypeRef = implicitReceiverStack.filterIsInstance<ImplicitDispatchReceiverValue>().lastOrNull()
?.boundSymbol?.fir?.superTypeRefs?.firstOrNull() ?.boundSymbol?.fir?.superTypeRefs?.firstOrNull()
?: FirErrorTypeRefImpl(session, qualifiedAccessExpression.psi, "No super type") ?: FirErrorTypeRefImpl(qualifiedAccessExpression.psi, "No super type")
qualifiedAccessExpression.resultType = superTypeRef qualifiedAccessExpression.resultType = superTypeRef
callee.replaceSuperTypeRef(superTypeRef) callee.replaceSuperTypeRef(superTypeRef)
} }
@@ -277,7 +275,7 @@ open class FirBodyResolveTransformer(
session, session,
null, null,
Name.identifier("it"), Name.identifier("it"),
FirResolvedTypeRefImpl(session, null, singleParameterType, emptyList()), FirResolvedTypeRefImpl(null, singleParameterType, emptyList()),
defaultValue = null, defaultValue = null,
isCrossinline = false, isCrossinline = false,
isNoinline = false, isNoinline = false,
@@ -311,7 +309,7 @@ open class FirBodyResolveTransformer(
returnTypeRef = (af.returnTypeRef as? FirResolvedTypeRef) returnTypeRef = (af.returnTypeRef as? FirResolvedTypeRef)
?: resolvedLambdaAtom?.returnType?.let { af.returnTypeRef.resolvedTypeFromPrototype(it) } ?: resolvedLambdaAtom?.returnType?.let { af.returnTypeRef.resolvedTypeFromPrototype(it) }
?: af.body?.resultType?.takeIf { af.returnTypeRef is FirImplicitTypeRef } ?: af.body?.resultType?.takeIf { af.returnTypeRef is FirImplicitTypeRef }
?: FirErrorTypeRefImpl(session, af.psi, "No result type for lambda") ?: FirErrorTypeRefImpl(af.psi, "No result type for lambda")
) )
af.replaceTypeRef(af.constructFunctionalTypeRef(session)) af.replaceTypeRef(af.constructFunctionalTypeRef(session))
af.compose() af.compose()
@@ -361,9 +359,9 @@ open class FirBodyResolveTransformer(
val type = commonSuperType((listOf(tryExpression.tryBlock) + tryExpression.catches.map { it.block }).map { val type = commonSuperType((listOf(tryExpression.tryBlock) + tryExpression.catches.map { it.block }).map {
val expression = it.statements.lastOrNull() as? FirExpression val expression = it.statements.lastOrNull() as? FirExpression
if (expression != null) { if (expression != null) {
(expression.resultType as? FirResolvedTypeRef) ?: FirErrorTypeRefImpl(session, null, "No type for when branch result") (expression.resultType as? FirResolvedTypeRef) ?: FirErrorTypeRefImpl(null, "No type for when branch result")
} else { } else {
FirImplicitUnitTypeRef(session, null) FirImplicitUnitTypeRef(null)
} }
}) })
if (type != null) tryExpression.resultType = type if (type != null) tryExpression.resultType = type
@@ -414,9 +412,9 @@ open class FirBodyResolveTransformer(
else -> null else -> null
} }
block.resultType = if (resultExpression == null) { block.resultType = if (resultExpression == null) {
FirImplicitUnitTypeRef(session, block.psi) FirImplicitUnitTypeRef(block.psi)
} else { } else {
(resultExpression.resultType as? FirResolvedTypeRef) ?: FirErrorTypeRefImpl(session, null, "No type for block") (resultExpression.resultType as? FirResolvedTypeRef) ?: FirErrorTypeRefImpl(null, "No type for block")
} }
return block.compose() return block.compose()
@@ -429,7 +427,7 @@ open class FirBodyResolveTransformer(
commonSuperType(types.map { it.coneTypeUnsafe() }) commonSuperType(types.map { it.coneTypeUnsafe() })
} }
} as ConeKotlinType } as ConeKotlinType
return FirResolvedTypeRefImpl(session, null, commonSuperType, emptyList()) return FirResolvedTypeRefImpl(null, commonSuperType, emptyList())
} }
override fun transformWhenExpression(whenExpression: FirWhenExpression, data: Any?): CompositeTransformResult<FirStatement> { override fun transformWhenExpression(whenExpression: FirWhenExpression, data: Any?): CompositeTransformResult<FirStatement> {
@@ -438,9 +436,9 @@ open class FirBodyResolveTransformer(
val type = commonSuperType(whenExpression.branches.map { val type = commonSuperType(whenExpression.branches.map {
val expression = it.result.statements.lastOrNull() as? FirExpression val expression = it.result.statements.lastOrNull() as? FirExpression
if (expression != null) { if (expression != null) {
(expression.resultType as? FirResolvedTypeRef) ?: FirErrorTypeRefImpl(session, null, "No type for when branch result") (expression.resultType as? FirResolvedTypeRef) ?: FirErrorTypeRefImpl(null, "No type for when branch result")
} else { } else {
FirImplicitUnitTypeRef(session, null) FirImplicitUnitTypeRef(null)
} }
}) })
if (type != null) whenExpression.resultType = type if (type != null) whenExpression.resultType = type
@@ -482,7 +480,7 @@ open class FirBodyResolveTransformer(
val type = ConeClassTypeImpl(symbol.toLookupTag(), emptyArray(), isNullable = kind == IrConstKind.Null) val type = ConeClassTypeImpl(symbol.toLookupTag(), emptyArray(), isNullable = kind == IrConstKind.Null)
constExpression.resultType = FirResolvedTypeRefImpl(session, null, type, emptyList()) constExpression.resultType = FirResolvedTypeRefImpl(null, type, emptyList())
} else { } else {
constExpression.resultType = expectedType constExpression.resultType = expectedType
} }
@@ -576,7 +574,6 @@ open class FirBodyResolveTransformer(
this, this,
when (val resultType = initializer.resultType) { when (val resultType = initializer.resultType) {
is FirImplicitTypeRef -> FirErrorTypeRefImpl( is FirImplicitTypeRef -> FirErrorTypeRefImpl(
session,
null, null,
"No result type for initializer" "No result type for initializer"
) )
@@ -589,7 +586,6 @@ open class FirBodyResolveTransformer(
this, this,
when (val resultType = variable.getter?.returnTypeRef) { when (val resultType = variable.getter?.returnTypeRef) {
is FirImplicitTypeRef -> FirErrorTypeRefImpl( is FirImplicitTypeRef -> FirErrorTypeRefImpl(
session,
null, null,
"No result type for getter" "No result type for getter"
) )
@@ -599,7 +595,7 @@ open class FirBodyResolveTransformer(
} }
else -> { else -> {
variable.transformReturnTypeRef( variable.transformReturnTypeRef(
this, FirErrorTypeRefImpl(session, null, "Cannot infer variable type without initializer / getter / delegate") this, FirErrorTypeRefImpl(null, "Cannot infer variable type without initializer / getter / delegate")
) )
} }
} }
@@ -674,7 +670,7 @@ open class FirBodyResolveTransformer(
override fun transformExpression(expression: FirExpression, data: Any?): CompositeTransformResult<FirStatement> { override fun transformExpression(expression: FirExpression, data: Any?): CompositeTransformResult<FirStatement> {
if (expression.resultType is FirImplicitTypeRef && expression !is FirWrappedExpression) { if (expression.resultType is FirImplicitTypeRef && expression !is FirWrappedExpression) {
val type = FirErrorTypeRefImpl(session, expression.psi, "Type calculating for ${expression::class} is not supported") val type = FirErrorTypeRefImpl(expression.psi, "Type calculating for ${expression::class} is not supported")
expression.resultType = type expression.resultType = type
} }
return (expression.transformChildren(this, data) as FirStatement).compose() return (expression.transformChildren(this, data) as FirStatement).compose()
@@ -705,7 +701,6 @@ open class FirBodyResolveTransformer(
transformedGetClassCall.resultType = transformedGetClassCall.resultType =
FirResolvedTypeRefImpl( FirResolvedTypeRefImpl(
session,
null, null,
kClassSymbol.constructType(arrayOf(typeOfExpression), false), kClassSymbol.constructType(arrayOf(typeOfExpression), false),
emptyList() emptyList()
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirCallCompletionResultsWriterTransformer.kt
+5 -11
View File
@@ -24,7 +24,6 @@ import org.jetbrains.kotlin.fir.types.impl.ConeTypeParameterTypeImpl
import org.jetbrains.kotlin.fir.types.impl.FirResolvedTypeRefImpl import org.jetbrains.kotlin.fir.types.impl.FirResolvedTypeRefImpl
import org.jetbrains.kotlin.fir.types.impl.FirTypeProjectionWithVarianceImpl import org.jetbrains.kotlin.fir.types.impl.FirTypeProjectionWithVarianceImpl
import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
import org.jetbrains.kotlin.fir.visitors.FirTransformer
import org.jetbrains.kotlin.fir.visitors.compose import org.jetbrains.kotlin.fir.visitors.compose
import org.jetbrains.kotlin.types.Variance import org.jetbrains.kotlin.types.Variance
@@ -47,13 +46,12 @@ class FirCallCompletionResultsWriterTransformer(
val initialType = calleeReference.candidate.substitutor.substituteOrNull(typeRef.type) val initialType = calleeReference.candidate.substitutor.substituteOrNull(typeRef.type)
val finalType = finalSubstitutor.substituteOrNull(initialType) val finalType = finalSubstitutor.substituteOrNull(initialType)
val resultType = typeRef.withReplacedConeType(session, finalType) val resultType = typeRef.withReplacedConeType(finalType)
qualifiedAccessExpression.replaceTypeRef(resultType) qualifiedAccessExpression.replaceTypeRef(resultType)
return qualifiedAccessExpression.transformCalleeReference( return qualifiedAccessExpression.transformCalleeReference(
StoreCalleeReference, StoreCalleeReference,
FirResolvedCallableReferenceImpl( FirResolvedCallableReferenceImpl(
calleeReference.session,
calleeReference.psi, calleeReference.psi,
calleeReference.name, calleeReference.name,
calleeReference.candidateSymbol calleeReference.candidateSymbol
@@ -70,7 +68,6 @@ class FirCallCompletionResultsWriterTransformer(
return variableAssignment.transformCalleeReference( return variableAssignment.transformCalleeReference(
StoreCalleeReference, StoreCalleeReference,
FirResolvedCallableReferenceImpl( FirResolvedCallableReferenceImpl(
calleeReference.session,
calleeReference.psi, calleeReference.psi,
calleeReference.name, calleeReference.name,
calleeReference.candidateSymbol calleeReference.candidateSymbol
@@ -92,18 +89,16 @@ class FirCallCompletionResultsWriterTransformer(
is FirTypeProjectionWithVariance -> { is FirTypeProjectionWithVariance -> {
val typeRef = argument.typeRef as FirResolvedTypeRef val typeRef = argument.typeRef as FirResolvedTypeRef
FirTypeProjectionWithVarianceImpl( FirTypeProjectionWithVarianceImpl(
session,
argument.psi, argument.psi,
argument.variance, argument.variance,
typeRef.withReplacedConeType(session, type) typeRef.withReplacedConeType(type)
) )
} }
else -> { else -> {
FirTypeProjectionWithVarianceImpl( FirTypeProjectionWithVarianceImpl(
session,
argument?.psi, argument?.psi,
Variance.INVARIANT, Variance.INVARIANT,
FirResolvedTypeRefImpl(session, null, type, emptyList()) FirResolvedTypeRefImpl(null, type, emptyList())
) )
} }
} }
@@ -114,13 +109,12 @@ class FirCallCompletionResultsWriterTransformer(
val initialType = subCandidate.substitutor.substituteOrNull(typeRef.type) val initialType = subCandidate.substitutor.substituteOrNull(typeRef.type)
val finalType = finalSubstitutor.substituteOrNull(initialType) val finalType = finalSubstitutor.substituteOrNull(initialType)
val resultType = typeRef.withReplacedConeType(session, finalType) val resultType = typeRef.withReplacedConeType(finalType)
return functionCall.copy( return functionCall.copy(
resultType = resultType, resultType = resultType,
typeArguments = newTypeParameters, typeArguments = newTypeParameters,
calleeReference = FirResolvedCallableReferenceImpl( calleeReference = FirResolvedCallableReferenceImpl(
calleeReference.session,
calleeReference.psi, calleeReference.psi,
calleeReference.name, calleeReference.name,
calleeReference.candidateSymbol calleeReference.candidateSymbol
@@ -137,7 +131,7 @@ class FirCallCompletionResultsWriterTransformer(
if (initialType != null) { if (initialType != null) {
val finalType = finalSubstitutor.substituteOrNull(initialType) val finalType = finalSubstitutor.substituteOrNull(initialType)
val resultType = anonymousFunction.returnTypeRef.withReplacedConeType(session, finalType) val resultType = anonymousFunction.returnTypeRef.withReplacedConeType(finalType)
anonymousFunction.transformReturnTypeRef(StoreType, resultType) anonymousFunction.transformReturnTypeRef(StoreType, resultType)
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirImportResolveTransformer.kt
+1 -1
View File
@@ -50,7 +50,7 @@ class FirImportResolveTransformer() : FirAbstractTreeTransformer() {
private fun transformImportForFqName(fqName: FqName, delegate: FirImport): CompositeTransformResult<FirImport> { private fun transformImportForFqName(fqName: FqName, delegate: FirImport): CompositeTransformResult<FirImport> {
val (packageFqName, relativeClassFqName) = resolveToPackageOrClass(symbolProvider, fqName) ?: return delegate.compose() val (packageFqName, relativeClassFqName) = resolveToPackageOrClass(symbolProvider, fqName) ?: return delegate.compose()
return FirResolvedImportImpl(session, delegate, packageFqName, relativeClassFqName).compose() return FirResolvedImportImpl(delegate, packageFqName, relativeClassFqName).compose()
} }
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSpecificTypeResolverTransformer.kt
-2
View File
@@ -33,7 +33,6 @@ class FirSpecificTypeResolverTransformer(
functionTypeRef.transformChildren(this, data) functionTypeRef.transformChildren(this, data)
return FirResolvedFunctionTypeRefImpl( return FirResolvedFunctionTypeRefImpl(
functionTypeRef.psi, functionTypeRef.psi,
session,
functionTypeRef.isMarkedNullable, functionTypeRef.isMarkedNullable,
functionTypeRef.annotations as MutableList<FirAnnotationCall>, functionTypeRef.annotations as MutableList<FirAnnotationCall>,
functionTypeRef.receiverTypeRef, functionTypeRef.receiverTypeRef,
@@ -45,7 +44,6 @@ class FirSpecificTypeResolverTransformer(
private fun transformType(typeRef: FirTypeRef, resolvedType: ConeKotlinType): CompositeTransformResult<FirTypeRef> { private fun transformType(typeRef: FirTypeRef, resolvedType: ConeKotlinType): CompositeTransformResult<FirTypeRef> {
return FirResolvedTypeRefImpl( return FirResolvedTypeRefImpl(
session,
typeRef.psi, typeRef.psi,
resolvedType, resolvedType,
typeRef.annotations typeRef.annotations
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSupertypeResolverTransformer.kt
+1 -1
View File
@@ -144,7 +144,7 @@ class FirSupertypeResolverTransformer : FirAbstractTreeTransformer() {
if (superTypeClassId.outerClasses().any(currentlyComputing::contains)) { if (superTypeClassId.outerClasses().any(currentlyComputing::contains)) {
resultingTypeRefs.add( resultingTypeRefs.add(
FirErrorTypeRefImpl(session, superTypeRef.psi, "Recursion detected: ${superTypeRef.render()}") FirErrorTypeRefImpl(superTypeRef.psi, "Recursion detected: ${superTypeRef.render()}")
) )
continue continue
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirTypeResolveTransformer.kt
-1
View File
@@ -104,7 +104,6 @@ open class FirTypeResolveTransformer : FirAbstractTreeTransformerWithSuperTypes(
valueParameter.transformReturnTypeRef( valueParameter.transformReturnTypeRef(
StoreType, StoreType,
valueParameter.returnTypeRef.withReplacedConeType( valueParameter.returnTypeRef.withReplacedConeType(
session,
returnType.createArrayOf(session) returnType.createArrayOf(session)
) )
) )
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/ReturnTypeCalculator.kt
+1 -3
View File
@@ -31,7 +31,7 @@ class ReturnTypeCalculatorWithJump(val session: FirSession, val scopeSession: Sc
if (declaration.returnTypeRef is FirComputingImplicitTypeRef) { if (declaration.returnTypeRef is FirComputingImplicitTypeRef) {
declaration.transformReturnTypeRef( declaration.transformReturnTypeRef(
TransformImplicitType, TransformImplicitType,
FirErrorTypeRefImpl(session, null, "cycle") FirErrorTypeRefImpl(null, "cycle")
) )
return declaration.returnTypeRef as FirResolvedTypeRef return declaration.returnTypeRef as FirResolvedTypeRef
} }
@@ -45,7 +45,6 @@ class ReturnTypeCalculatorWithJump(val session: FirSession, val scopeSession: Sc
declaration.transformReturnTypeRef( declaration.transformReturnTypeRef(
TransformImplicitType, TransformImplicitType,
FirErrorTypeRefImpl( FirErrorTypeRefImpl(
session,
null, null,
"Unsupported: implicit VP type" "Unsupported: implicit VP type"
) )
@@ -69,7 +68,6 @@ class ReturnTypeCalculatorWithJump(val session: FirSession, val scopeSession: Sc
}.mapTo(mutableListOf()) { provider.getFirClassifierByFqName(it) } }.mapTo(mutableListOf()) { provider.getFirClassifierByFqName(it) }
if (file == null || outerClasses.any { it == null }) return FirErrorTypeRefImpl( if (file == null || outerClasses.any { it == null }) return FirErrorTypeRefImpl(
session,
null, null,
"I don't know what todo" "I don't know what todo"
) )
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirClassSubstitutionScope.kt
+5 -8
View File
@@ -92,8 +92,8 @@ class FirClassSubstitutionScope(
FirMemberFunctionImpl( FirMemberFunctionImpl(
session, session,
psi, symbol, name, psi, symbol, name,
baseFunction.receiverTypeRef?.withReplacedConeType(session, newReceiverType), baseFunction.receiverTypeRef?.withReplacedConeType(newReceiverType),
baseFunction.returnTypeRef.withReplacedConeType(session, newReturnType) baseFunction.returnTypeRef.withReplacedConeType(newReturnType)
).apply { ).apply {
status = baseFunction.status as FirDeclarationStatusImpl status = baseFunction.status as FirDeclarationStatusImpl
valueParameters += baseFunction.valueParameters.zip( valueParameters += baseFunction.valueParameters.zip(
@@ -102,7 +102,7 @@ class FirClassSubstitutionScope(
with(valueParameter) { with(valueParameter) {
FirValueParameterImpl( FirValueParameterImpl(
session, psi, session, psi,
name, this.returnTypeRef.withReplacedConeType(session, newType), name, this.returnTypeRef.withReplacedConeType(newType),
defaultValue, isCrossinline, isNoinline, isVararg, defaultValue, isCrossinline, isNoinline, isVararg,
FirVariableSymbol(valueParameter.symbol.callableId) FirVariableSymbol(valueParameter.symbol.callableId)
) )
@@ -116,13 +116,10 @@ class FirClassSubstitutionScope(
} }
fun FirTypeRef.withReplacedConeType(session: FirSession, newType: ConeKotlinType?): FirResolvedTypeRef { fun FirTypeRef.withReplacedConeType(newType: ConeKotlinType?): FirResolvedTypeRef {
require(this is FirResolvedTypeRef) require(this is FirResolvedTypeRef)
if (newType == null) return this if (newType == null) return this
return FirResolvedTypeRefImpl( return FirResolvedTypeRefImpl(psi, newType, annotations = annotations)
session, psi, newType,
annotations = annotations
)
} }
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirDefaultSimpleImportingScope.kt
+1 -1
View File
@@ -21,7 +21,7 @@ class FirDefaultSimpleImportingScope(session: FirSession) : FirAbstractSimpleImp
session.moduleInfo?.analyzerServices?.getDefaultImports(LanguageVersionSettingsImpl.DEFAULT, true) session.moduleInfo?.analyzerServices?.getDefaultImports(LanguageVersionSettingsImpl.DEFAULT, true)
?.filter { !it.isAllUnder } ?.filter { !it.isAllUnder }
?.map { ?.map {
FirImportImpl(session, null, it.fqName, isAllUnder = false, aliasName = null) FirImportImpl(null, it.fqName, isAllUnder = false, aliasName = null)
.resolve(importResolveTransformer) .resolve(importResolveTransformer)
}?.groupBy { it.importedName!! } ?: emptyMap() }?.groupBy { it.importedName!! } ?: emptyMap()
} }
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirDefaultStarImportingScope.kt
+1 -2
View File
@@ -18,8 +18,7 @@ class FirDefaultStarImportingScope(session: FirSession, lookupInFir: Boolean = f
?.filter { it.isAllUnder } ?.filter { it.isAllUnder }
?.map { ?.map {
FirResolvedImportImpl( FirResolvedImportImpl(
session, FirImportImpl(null, it.fqName, isAllUnder = true, aliasName = null),
FirImportImpl(session, null, it.fqName, isAllUnder = true, aliasName = null),
it.fqName, it.fqName,
null null
) )
compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirAbstractElement.kt
-1
View File
@@ -10,6 +10,5 @@ import com.intellij.psi.PsiElement
abstract class FirPureAbstractElement : FirElement abstract class FirPureAbstractElement : FirElement
abstract class FirAbstractElement( abstract class FirAbstractElement(
final override val session: FirSession,
final override val psi: PsiElement? final override val psi: PsiElement?
) : FirPureAbstractElement() ) : FirPureAbstractElement()
compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirElement.kt
-3
View File
@@ -14,9 +14,6 @@ import org.jetbrains.kotlin.fir.visitors.FirVisitorVoid
interface FirElement { interface FirElement {
val psi: PsiElement? val psi: PsiElement?
@Deprecated("It's generally better to obtain use-site session from external source")
val session: FirSession
fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
visitor.visitElement(this, data) visitor.visitElement(this, data)
compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirAnonymousFunction.kt
+2 -2
View File
@@ -14,9 +14,9 @@ import org.jetbrains.kotlin.fir.types.FirTypeRef
import org.jetbrains.kotlin.fir.visitors.FirVisitor import org.jetbrains.kotlin.fir.visitors.FirVisitor
abstract class FirAnonymousFunction( abstract class FirAnonymousFunction(
session: FirSession, final override val session: FirSession,
psi: PsiElement? psi: PsiElement?
) : @VisitedSupertype FirFunction, FirUnknownTypeExpression(session, psi), FirTypedDeclaration, FirLabeledElement { ) : @VisitedSupertype FirFunction, FirUnknownTypeExpression(psi), FirTypedDeclaration, FirLabeledElement {
abstract val receiverTypeRef: FirTypeRef? abstract val receiverTypeRef: FirTypeRef?
override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirAnonymousObject.kt
+1 -6
View File
@@ -7,16 +7,11 @@ package org.jetbrains.kotlin.fir.declarations
import com.intellij.psi.PsiElement import com.intellij.psi.PsiElement
import org.jetbrains.kotlin.descriptors.ClassKind import org.jetbrains.kotlin.descriptors.ClassKind
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.VisitedSupertype import org.jetbrains.kotlin.fir.VisitedSupertype
import org.jetbrains.kotlin.fir.expressions.FirExpression
import org.jetbrains.kotlin.fir.expressions.impl.FirUnknownTypeExpression import org.jetbrains.kotlin.fir.expressions.impl.FirUnknownTypeExpression
import org.jetbrains.kotlin.fir.visitors.FirVisitor import org.jetbrains.kotlin.fir.visitors.FirVisitor
abstract class FirAnonymousObject( abstract class FirAnonymousObject(psi: PsiElement?) : @VisitedSupertype FirClass, FirUnknownTypeExpression(psi) {
session: FirSession,
psi: PsiElement?
) : @VisitedSupertype FirClass, FirUnknownTypeExpression(session, psi) {
override val classKind: ClassKind override val classKind: ClassKind
get() = ClassKind.OBJECT get() = ClassKind.OBJECT
compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirDeclaration.kt
+3
View File
@@ -7,11 +7,14 @@ package org.jetbrains.kotlin.fir.declarations
import org.jetbrains.kotlin.fir.BaseTransformedType import org.jetbrains.kotlin.fir.BaseTransformedType
import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.FirElement
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.visitors.FirVisitor import org.jetbrains.kotlin.fir.visitors.FirVisitor
@BaseTransformedType @BaseTransformedType
interface FirDeclaration : FirElement { interface FirDeclaration : FirElement {
val session: FirSession
override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
visitor.visitDeclaration(this, data) visitor.visitDeclaration(this, data)
} }
compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirEnumEntry.kt
+2 -2
View File
@@ -14,9 +14,9 @@ import org.jetbrains.kotlin.fir.visitors.FirVisitor
@BaseTransformedType @BaseTransformedType
abstract class FirEnumEntry( abstract class FirEnumEntry(
session: FirSession, final override val session: FirSession,
psi: PsiElement? psi: PsiElement?
) : @VisitedSupertype FirRegularClass, FirCall(session, psi) { ) : @VisitedSupertype FirRegularClass, FirCall(psi) {
override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
visitor.visitEnumEntry(this, data) visitor.visitEnumEntry(this, data)
compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirAbstractAnnotatedDeclaration.kt
+2 -2
View File
@@ -11,6 +11,6 @@ import org.jetbrains.kotlin.fir.declarations.FirDeclaration
import org.jetbrains.kotlin.fir.expressions.impl.FirAbstractAnnotatedElement import org.jetbrains.kotlin.fir.expressions.impl.FirAbstractAnnotatedElement
abstract class FirAbstractAnnotatedDeclaration( abstract class FirAbstractAnnotatedDeclaration(
session: FirSession, final override val session: FirSession,
psi: PsiElement? psi: PsiElement?
) : FirAbstractAnnotatedElement(session, psi), FirDeclaration ) : FirAbstractAnnotatedElement(psi), FirDeclaration
compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirAbstractMemberDeclaration.kt
-1
View File
@@ -32,7 +32,6 @@ abstract class FirAbstractMemberDeclaration(
isActual: Boolean isActual: Boolean
) : this(session, psi, name) { ) : this(session, psi, name) {
this.status = FirDeclarationStatusImpl( this.status = FirDeclarationStatusImpl(
session,
visibility, visibility,
modality modality
).apply { ).apply {
compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirAnonymousInitializerImpl.kt
+2 -2
View File
@@ -15,10 +15,10 @@ import org.jetbrains.kotlin.fir.transformSingle
import org.jetbrains.kotlin.fir.visitors.FirTransformer import org.jetbrains.kotlin.fir.visitors.FirTransformer
class FirAnonymousInitializerImpl( class FirAnonymousInitializerImpl(
session: FirSession, override val session: FirSession,
psi: PsiElement?, psi: PsiElement?,
override var body: FirBlock? override var body: FirBlock?
) : FirAnonymousInitializer, FirAbstractElement(session, psi) { ) : FirAnonymousInitializer, FirAbstractElement(psi) {
override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement { override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
body = body?.transformSingle(transformer, data) body = body?.transformSingle(transformer, data)
return this return this
compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirAnonymousObjectImpl.kt
+1 -5
View File
@@ -7,7 +7,6 @@ package org.jetbrains.kotlin.fir.declarations.impl
import com.intellij.psi.PsiElement import com.intellij.psi.PsiElement
import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.FirElement
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.declarations.FirAnonymousObject import org.jetbrains.kotlin.fir.declarations.FirAnonymousObject
import org.jetbrains.kotlin.fir.declarations.FirDeclaration import org.jetbrains.kotlin.fir.declarations.FirDeclaration
import org.jetbrains.kotlin.fir.transformInplace import org.jetbrains.kotlin.fir.transformInplace
@@ -15,10 +14,7 @@ import org.jetbrains.kotlin.fir.types.FirTypeRef
import org.jetbrains.kotlin.fir.visitors.FirTransformer import org.jetbrains.kotlin.fir.visitors.FirTransformer
import org.jetbrains.kotlin.fir.visitors.FirVisitor import org.jetbrains.kotlin.fir.visitors.FirVisitor
class FirAnonymousObjectImpl( class FirAnonymousObjectImpl(psi: PsiElement?) : FirAnonymousObject(psi), FirModifiableClass {
session: FirSession,
psi: PsiElement?
) : FirAnonymousObject(session, psi), FirModifiableClass {
override val superTypeRefs = mutableListOf<FirTypeRef>() override val superTypeRefs = mutableListOf<FirTypeRef>()
override val declarations = mutableListOf<FirDeclaration>() override val declarations = mutableListOf<FirDeclaration>()
compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirClassImpl.kt
-1
View File
@@ -10,7 +10,6 @@ import org.jetbrains.kotlin.descriptors.ClassKind
import org.jetbrains.kotlin.descriptors.Modality import org.jetbrains.kotlin.descriptors.Modality
import org.jetbrains.kotlin.descriptors.Visibility import org.jetbrains.kotlin.descriptors.Visibility
import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.declarations.FirConstructor
import org.jetbrains.kotlin.fir.declarations.FirDeclaration import org.jetbrains.kotlin.fir.declarations.FirDeclaration
import org.jetbrains.kotlin.fir.declarations.FirRegularClass import org.jetbrains.kotlin.fir.declarations.FirRegularClass
import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirDeclarationStatusImpl.kt
+2 -4
View File
@@ -8,15 +8,13 @@ package org.jetbrains.kotlin.fir.declarations.impl
import org.jetbrains.kotlin.descriptors.Modality import org.jetbrains.kotlin.descriptors.Modality
import org.jetbrains.kotlin.descriptors.Visibility import org.jetbrains.kotlin.descriptors.Visibility
import org.jetbrains.kotlin.fir.FirAbstractElement import org.jetbrains.kotlin.fir.FirAbstractElement
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.declarations.FirDeclarationStatus import org.jetbrains.kotlin.fir.declarations.FirDeclarationStatus
import org.jetbrains.kotlin.fir.declarations.impl.FirDeclarationStatusImpl.Modifier.* import org.jetbrains.kotlin.fir.declarations.impl.FirDeclarationStatusImpl.Modifier.*
open class FirDeclarationStatusImpl( open class FirDeclarationStatusImpl(
session: FirSession,
override val visibility: Visibility, override val visibility: Visibility,
override val modality: Modality? override val modality: Modality?
) : FirAbstractElement(session, null), FirDeclarationStatus { ) : FirAbstractElement(null), FirDeclarationStatus {
protected var flags: Int = 0 protected var flags: Int = 0
private operator fun get(modifier: Modifier): Boolean = (flags and modifier.mask) != 0 private operator fun get(modifier: Modifier): Boolean = (flags and modifier.mask) != 0
@@ -138,6 +136,6 @@ open class FirDeclarationStatusImpl(
} }
fun resolved(visibility: Visibility, modality: Modality): FirDeclarationStatus { fun resolved(visibility: Visibility, modality: Modality): FirDeclarationStatus {
return FirResolvedDeclarationStatusImpl(session, visibility, modality, flags) return FirResolvedDeclarationStatusImpl(visibility, modality, flags)
} }
} }
compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirDefaultPropertyAccessor.kt
+4 -7
View File
@@ -14,7 +14,6 @@ import org.jetbrains.kotlin.fir.declarations.FirValueParameter
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
import org.jetbrains.kotlin.fir.expressions.FirBlock import org.jetbrains.kotlin.fir.expressions.FirBlock
import org.jetbrains.kotlin.fir.symbols.CallableId import org.jetbrains.kotlin.fir.symbols.CallableId
import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol
import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol
import org.jetbrains.kotlin.fir.transformInplace import org.jetbrains.kotlin.fir.transformInplace
import org.jetbrains.kotlin.fir.transformSingle import org.jetbrains.kotlin.fir.transformSingle
@@ -25,14 +24,12 @@ import org.jetbrains.kotlin.name.FqName
import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.name.Name
abstract class FirDefaultPropertyAccessor( abstract class FirDefaultPropertyAccessor(
session: FirSession, final override val session: FirSession,
psi: PsiElement?, psi: PsiElement?,
final override val isGetter: Boolean, final override val isGetter: Boolean,
visibility: Visibility visibility: Visibility
) : FirAbstractElement(session, psi), FirPropertyAccessor { ) : FirAbstractElement(psi), FirPropertyAccessor {
override var status = FirDeclarationStatusImpl( override var status = FirDeclarationStatusImpl(visibility, Modality.FINAL)
session, visibility, Modality.FINAL
)
final override val body: FirBlock? = final override val body: FirBlock? =
null null
@@ -81,7 +78,7 @@ class FirDefaultPropertySetter(
) )
) )
override var returnTypeRef: FirTypeRef = FirImplicitUnitTypeRef(session, psi) override var returnTypeRef: FirTypeRef = FirImplicitUnitTypeRef(psi)
override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement { override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
valueParameters.transformInplace(transformer, data) valueParameters.transformInplace(transformer, data)
compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirEnumEntryImpl.kt
+2 -2
View File
@@ -32,7 +32,7 @@ class FirEnumEntryImpl(
symbol.bind(this) symbol.bind(this)
} }
override var status = FirDeclarationStatusImpl(session, Visibilities.UNKNOWN, Modality.FINAL) override var status = FirDeclarationStatusImpl(Visibilities.UNKNOWN, Modality.FINAL)
override val classKind: ClassKind override val classKind: ClassKind
get() = ClassKind.ENUM_ENTRY get() = ClassKind.ENUM_ENTRY
@@ -46,7 +46,7 @@ class FirEnumEntryImpl(
override val companionObject: FirRegularClass? override val companionObject: FirRegularClass?
get() = null get() = null
override var typeRef: FirTypeRef = FirImplicitEnumTypeRef(session, null) override var typeRef: FirTypeRef = FirImplicitEnumTypeRef(null)
override val arguments = mutableListOf<FirExpression>() override val arguments = mutableListOf<FirExpression>()
compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirErrorFunction.kt
+2 -2
View File
@@ -16,10 +16,10 @@ import org.jetbrains.kotlin.fir.expressions.FirBlock
import org.jetbrains.kotlin.fir.visitors.FirVisitor import org.jetbrains.kotlin.fir.visitors.FirVisitor
class FirErrorFunction( class FirErrorFunction(
session: FirSession, override val session: FirSession,
psi: PsiElement?, psi: PsiElement?,
override val reason: String override val reason: String
) : FirAbstractElement(session, psi), FirErrorDeclaration, FirFunction { ) : FirAbstractElement(psi), FirErrorDeclaration, FirFunction {
override val annotations: List<FirAnnotationCall> override val annotations: List<FirAnnotationCall>
get() = emptyList() get() = emptyList()
compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirErrorLoop.kt
+3 -5
View File
@@ -7,22 +7,20 @@ package org.jetbrains.kotlin.fir.declarations.impl
import com.intellij.psi.PsiElement import com.intellij.psi.PsiElement
import org.jetbrains.kotlin.fir.FirAbstractElement import org.jetbrains.kotlin.fir.FirAbstractElement
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.expressions.* import org.jetbrains.kotlin.fir.expressions.*
import org.jetbrains.kotlin.fir.expressions.impl.FirEmptyExpressionBlock import org.jetbrains.kotlin.fir.expressions.impl.FirEmptyExpressionBlock
import org.jetbrains.kotlin.fir.expressions.impl.FirErrorExpressionImpl import org.jetbrains.kotlin.fir.expressions.impl.FirErrorExpressionImpl
import org.jetbrains.kotlin.fir.visitors.FirVisitor import org.jetbrains.kotlin.fir.visitors.FirVisitor
class FirErrorLoop( class FirErrorLoop(
session: FirSession,
psi: PsiElement?, psi: PsiElement?,
override val reason: String override val reason: String
) : FirAbstractElement(session, psi), FirErrorStatement, FirLoop { ) : FirAbstractElement(psi), FirErrorStatement, FirLoop {
override val annotations: List<FirAnnotationCall> = listOf() override val annotations: List<FirAnnotationCall> = listOf()
override val condition: FirExpression = FirErrorExpressionImpl(session, psi, reason) override val condition: FirExpression = FirErrorExpressionImpl(psi, reason)
override val block: FirBlock = FirEmptyExpressionBlock(session) override val block: FirBlock = FirEmptyExpressionBlock()
override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R { override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R {
return super<FirErrorStatement>.accept(visitor, data) return super<FirErrorStatement>.accept(visitor, data)
compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirImportImpl.kt
+1 -3
View File
@@ -7,15 +7,13 @@ package org.jetbrains.kotlin.fir.declarations.impl
import com.intellij.psi.PsiElement import com.intellij.psi.PsiElement
import org.jetbrains.kotlin.fir.FirAbstractElement import org.jetbrains.kotlin.fir.FirAbstractElement
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.declarations.FirImport import org.jetbrains.kotlin.fir.declarations.FirImport
import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.FqName
import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.name.Name
class FirImportImpl( class FirImportImpl(
session: FirSession,
psi: PsiElement?, psi: PsiElement?,
override val importedFqName: FqName?, override val importedFqName: FqName?,
override val isAllUnder: Boolean, override val isAllUnder: Boolean,
override val aliasName: Name? override val aliasName: Name?
) : FirImport, FirAbstractElement(session, psi) ) : FirImport, FirAbstractElement(psi)
compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirPropertyAccessorImpl.kt
+1 -3
View File
@@ -22,9 +22,7 @@ class FirPropertyAccessorImpl(
visibility: Visibility, visibility: Visibility,
override var returnTypeRef: FirTypeRef override var returnTypeRef: FirTypeRef
) : FirAbstractFunction(session, psi), FirPropertyAccessor { ) : FirAbstractFunction(session, psi), FirPropertyAccessor {
override var status = FirDeclarationStatusImpl( override var status = FirDeclarationStatusImpl(visibility, Modality.FINAL)
session, visibility, Modality.FINAL
)
override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement { override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
returnTypeRef = returnTypeRef.transformSingle(transformer, data) returnTypeRef = returnTypeRef.transformSingle(transformer, data)
compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirResolvedDeclarationStatusImpl.kt
+2 -6
View File
@@ -5,24 +5,20 @@
package org.jetbrains.kotlin.fir.declarations.impl package org.jetbrains.kotlin.fir.declarations.impl
import com.intellij.psi.PsiElement
import org.jetbrains.kotlin.descriptors.Modality import org.jetbrains.kotlin.descriptors.Modality
import org.jetbrains.kotlin.descriptors.Visibility import org.jetbrains.kotlin.descriptors.Visibility
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.declarations.FirResolvedDeclarationStatus import org.jetbrains.kotlin.fir.declarations.FirResolvedDeclarationStatus
class FirResolvedDeclarationStatusImpl( class FirResolvedDeclarationStatusImpl(
session: FirSession,
visibility: Visibility, visibility: Visibility,
modality: Modality modality: Modality
) : FirDeclarationStatusImpl(session, visibility, modality), FirResolvedDeclarationStatus { ) : FirDeclarationStatusImpl(visibility, modality), FirResolvedDeclarationStatus {
internal constructor( internal constructor(
session: FirSession,
visibility: Visibility, visibility: Visibility,
modality: Modality, modality: Modality,
flags: Int flags: Int
) : this(session, visibility, modality) { ) : this(visibility, modality) {
this.flags = flags this.flags = flags
} }
compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirResolvedImportImpl.kt
+1 -3
View File
@@ -6,18 +6,16 @@
package org.jetbrains.kotlin.fir.declarations.impl package org.jetbrains.kotlin.fir.declarations.impl
import org.jetbrains.kotlin.fir.FirAbstractElement import org.jetbrains.kotlin.fir.FirAbstractElement
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.declarations.FirImport import org.jetbrains.kotlin.fir.declarations.FirImport
import org.jetbrains.kotlin.fir.declarations.FirResolvedImport import org.jetbrains.kotlin.fir.declarations.FirResolvedImport
import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.FqName
import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.name.Name
class FirResolvedImportImpl( class FirResolvedImportImpl(
session: FirSession,
val delegate: FirImport, val delegate: FirImport,
override val packageFqName: FqName, override val packageFqName: FqName,
override val relativeClassName: FqName? override val relativeClassName: FqName?
) : FirAbstractElement(session, delegate.psi), FirResolvedImport, FirImport { ) : FirAbstractElement(delegate.psi), FirResolvedImport, FirImport {
override val aliasName: Name? override val aliasName: Name?
get() = delegate.aliasName get() = delegate.aliasName
compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirAnnotationCall.kt
+1 -4
View File
@@ -16,10 +16,7 @@ import org.jetbrains.kotlin.fir.types.*
import org.jetbrains.kotlin.fir.visitors.FirVisitor import org.jetbrains.kotlin.fir.visitors.FirVisitor
import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.FqName
abstract class FirAnnotationCall( abstract class FirAnnotationCall(psi: PsiElement?) : FirCallWithArgumentList(psi) {
session: FirSession,
psi: PsiElement?
) : FirCallWithArgumentList(session, psi) {
abstract val annotationTypeRef: FirTypeRef abstract val annotationTypeRef: FirTypeRef
// May be should be not-null (with correct default target) // May be should be not-null (with correct default target)
compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirArrayOfCall.kt
+1 -5
View File
@@ -6,14 +6,10 @@
package org.jetbrains.kotlin.fir.expressions package org.jetbrains.kotlin.fir.expressions
import com.intellij.psi.PsiElement import com.intellij.psi.PsiElement
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.expressions.impl.FirUnknownTypeCallWithArgumentList import org.jetbrains.kotlin.fir.expressions.impl.FirUnknownTypeCallWithArgumentList
import org.jetbrains.kotlin.fir.visitors.FirVisitor import org.jetbrains.kotlin.fir.visitors.FirVisitor
abstract class FirArrayOfCall( abstract class FirArrayOfCall(psi: PsiElement?) : FirUnknownTypeCallWithArgumentList(psi) {
session: FirSession,
psi: PsiElement?
) : FirUnknownTypeCallWithArgumentList(session, psi) {
override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
visitor.visitArrayOfCall(this, data) visitor.visitArrayOfCall(this, data)
} }
compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirArraySetCall.kt
+1 -3
View File
@@ -6,14 +6,12 @@
package org.jetbrains.kotlin.fir.expressions package org.jetbrains.kotlin.fir.expressions
import com.intellij.psi.PsiElement import com.intellij.psi.PsiElement
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.VisitedSupertype import org.jetbrains.kotlin.fir.VisitedSupertype
import org.jetbrains.kotlin.fir.visitors.FirVisitor import org.jetbrains.kotlin.fir.visitors.FirVisitor
abstract class FirArraySetCall( abstract class FirArraySetCall(
session: FirSession,
psi: PsiElement? psi: PsiElement?
) : @VisitedSupertype FirCall(session, psi), FirAssignment { ) : @VisitedSupertype FirCall(psi), FirAssignment {
// NB: arguments of this thing are indexes AND rvalue // NB: arguments of this thing are indexes AND rvalue
abstract val indexes: List<FirExpression> abstract val indexes: List<FirExpression>
compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirBlock.kt
+1 -5
View File
@@ -6,14 +6,10 @@
package org.jetbrains.kotlin.fir.expressions package org.jetbrains.kotlin.fir.expressions
import com.intellij.psi.PsiElement import com.intellij.psi.PsiElement
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.expressions.impl.FirUnknownTypeExpression import org.jetbrains.kotlin.fir.expressions.impl.FirUnknownTypeExpression
import org.jetbrains.kotlin.fir.visitors.FirVisitor import org.jetbrains.kotlin.fir.visitors.FirVisitor
abstract class FirBlock( abstract class FirBlock(psi: PsiElement?) : FirUnknownTypeExpression(psi) {
session: FirSession,
psi: PsiElement?
) : FirUnknownTypeExpression(session, psi) {
abstract val statements: List<FirStatement> abstract val statements: List<FirStatement>
override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirBreakExpression.kt
+1 -5
View File
@@ -6,14 +6,10 @@
package org.jetbrains.kotlin.fir.expressions package org.jetbrains.kotlin.fir.expressions
import com.intellij.psi.PsiElement import com.intellij.psi.PsiElement
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.expressions.impl.FirLoopJump import org.jetbrains.kotlin.fir.expressions.impl.FirLoopJump
import org.jetbrains.kotlin.fir.visitors.FirVisitor import org.jetbrains.kotlin.fir.visitors.FirVisitor
abstract class FirBreakExpression( abstract class FirBreakExpression(psi: PsiElement?) : FirLoopJump(psi) {
session: FirSession,
psi: PsiElement?
) : FirLoopJump(session, psi) {
override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
visitor.visitBreakExpression(this, data) visitor.visitBreakExpression(this, data)
} }
compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirCall.kt
+1 -5
View File
@@ -7,15 +7,11 @@ package org.jetbrains.kotlin.fir.expressions
import com.intellij.psi.PsiElement import com.intellij.psi.PsiElement
import org.jetbrains.kotlin.fir.BaseTransformedType import org.jetbrains.kotlin.fir.BaseTransformedType
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.visitors.FirTransformer import org.jetbrains.kotlin.fir.visitors.FirTransformer
import org.jetbrains.kotlin.fir.visitors.FirVisitor import org.jetbrains.kotlin.fir.visitors.FirVisitor
@BaseTransformedType @BaseTransformedType
abstract class FirCall( abstract class FirCall(psi: PsiElement?) : FirExpression(psi) {
session: FirSession,
psi: PsiElement?
) : FirExpression(session, psi) {
abstract val arguments: List<FirExpression> abstract val arguments: List<FirExpression>
override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirCallableReferenceAccess.kt
+1 -5
View File
@@ -6,13 +6,9 @@
package org.jetbrains.kotlin.fir.expressions package org.jetbrains.kotlin.fir.expressions
import com.intellij.psi.PsiElement import com.intellij.psi.PsiElement
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.visitors.FirVisitor import org.jetbrains.kotlin.fir.visitors.FirVisitor
abstract class FirCallableReferenceAccess( abstract class FirCallableReferenceAccess(psi: PsiElement?) : FirQualifiedAccessExpression(psi) {
session: FirSession,
psi: PsiElement?
) : FirQualifiedAccessExpression(session, psi) {
override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
visitor.visitCallableReferenceAccess(this, data) visitor.visitCallableReferenceAccess(this, data)
} }
compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirClassReferenceExpression.kt
+1 -5
View File
@@ -6,15 +6,11 @@
package org.jetbrains.kotlin.fir.expressions package org.jetbrains.kotlin.fir.expressions
import com.intellij.psi.PsiElement import com.intellij.psi.PsiElement
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.expressions.impl.FirUnknownTypeExpression import org.jetbrains.kotlin.fir.expressions.impl.FirUnknownTypeExpression
import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.fir.types.FirTypeRef
import org.jetbrains.kotlin.fir.visitors.FirVisitor import org.jetbrains.kotlin.fir.visitors.FirVisitor
abstract class FirClassReferenceExpression( abstract class FirClassReferenceExpression(psi: PsiElement?) : FirUnknownTypeExpression(psi) {
session: FirSession,
psi: PsiElement?
) : FirUnknownTypeExpression(session, psi) {
abstract val classTypeRef: FirTypeRef abstract val classTypeRef: FirTypeRef
override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirComponentCall.kt
+1 -5
View File
@@ -6,13 +6,9 @@
package org.jetbrains.kotlin.fir.expressions package org.jetbrains.kotlin.fir.expressions
import com.intellij.psi.PsiElement import com.intellij.psi.PsiElement
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.visitors.FirVisitor import org.jetbrains.kotlin.fir.visitors.FirVisitor
abstract class FirComponentCall( abstract class FirComponentCall(psi: PsiElement?) : FirFunctionCall(psi) {
session: FirSession,
psi: PsiElement?
) : FirFunctionCall(session, psi) {
// Starting from 1, not from 0 // Starting from 1, not from 0
abstract val componentIndex: Int abstract val componentIndex: Int
compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirConstExpression.kt
+1 -5
View File
@@ -6,15 +6,11 @@
package org.jetbrains.kotlin.fir.expressions package org.jetbrains.kotlin.fir.expressions
import com.intellij.psi.PsiElement import com.intellij.psi.PsiElement
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.expressions.impl.FirUnknownTypeExpression import org.jetbrains.kotlin.fir.expressions.impl.FirUnknownTypeExpression
import org.jetbrains.kotlin.fir.visitors.FirVisitor import org.jetbrains.kotlin.fir.visitors.FirVisitor
import org.jetbrains.kotlin.ir.expressions.IrConstKind import org.jetbrains.kotlin.ir.expressions.IrConstKind
abstract class FirConstExpression<T>( abstract class FirConstExpression<T>(psi: PsiElement?) : FirUnknownTypeExpression(psi) {
session: FirSession,
psi: PsiElement?
) : FirUnknownTypeExpression(session, psi) {
abstract val kind: IrConstKind<T> abstract val kind: IrConstKind<T>
abstract val value: T abstract val value: T
compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirContinueExpression.kt
+1 -5
View File
@@ -6,14 +6,10 @@
package org.jetbrains.kotlin.fir.expressions package org.jetbrains.kotlin.fir.expressions
import com.intellij.psi.PsiElement import com.intellij.psi.PsiElement
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.expressions.impl.FirLoopJump import org.jetbrains.kotlin.fir.expressions.impl.FirLoopJump
import org.jetbrains.kotlin.fir.visitors.FirVisitor import org.jetbrains.kotlin.fir.visitors.FirVisitor
abstract class FirContinueExpression( abstract class FirContinueExpression(psi: PsiElement?) : FirLoopJump(psi) {
session: FirSession,
psi: PsiElement?
) : FirLoopJump(session, psi) {
override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
visitor.visitContinueExpression(this, data) visitor.visitContinueExpression(this, data)
} }
compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirDelegatedConstructorCall.kt
+1 -3
View File
@@ -6,16 +6,14 @@
package org.jetbrains.kotlin.fir.expressions package org.jetbrains.kotlin.fir.expressions
import com.intellij.psi.PsiElement import com.intellij.psi.PsiElement
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.VisitedSupertype import org.jetbrains.kotlin.fir.VisitedSupertype
import org.jetbrains.kotlin.fir.expressions.impl.FirCallWithArgumentList import org.jetbrains.kotlin.fir.expressions.impl.FirCallWithArgumentList
import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.fir.types.FirTypeRef
import org.jetbrains.kotlin.fir.visitors.FirVisitor import org.jetbrains.kotlin.fir.visitors.FirVisitor
abstract class FirDelegatedConstructorCall( abstract class FirDelegatedConstructorCall(
session: FirSession,
psi: PsiElement? psi: PsiElement?
) : @VisitedSupertype FirCallWithArgumentList(session, psi), FirQualifiedAccess { ) : @VisitedSupertype FirCallWithArgumentList(psi), FirQualifiedAccess {
// Do we need 'constructedType: FirType' here? // Do we need 'constructedType: FirType' here?
abstract val constructedTypeRef: FirTypeRef abstract val constructedTypeRef: FirTypeRef
compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirErrorExpression.kt
+1 -5
View File
@@ -6,14 +6,10 @@
package org.jetbrains.kotlin.fir.expressions package org.jetbrains.kotlin.fir.expressions
import com.intellij.psi.PsiElement import com.intellij.psi.PsiElement
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.expressions.impl.FirUnknownTypeExpression import org.jetbrains.kotlin.fir.expressions.impl.FirUnknownTypeExpression
import org.jetbrains.kotlin.fir.visitors.FirVisitor import org.jetbrains.kotlin.fir.visitors.FirVisitor
abstract class FirErrorExpression( abstract class FirErrorExpression(psi: PsiElement?) : FirUnknownTypeExpression(psi) {
session: FirSession,
psi: PsiElement?
) : FirUnknownTypeExpression(session, psi) {
abstract val reason: String abstract val reason: String
override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R { override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R {
compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirExpression.kt
+1 -3
View File
@@ -7,16 +7,14 @@ package org.jetbrains.kotlin.fir.expressions
import com.intellij.psi.PsiElement import com.intellij.psi.PsiElement
import org.jetbrains.kotlin.fir.FirResolvedCallableReference import org.jetbrains.kotlin.fir.FirResolvedCallableReference
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.expressions.impl.FirAnnotatedStatement import org.jetbrains.kotlin.fir.expressions.impl.FirAnnotatedStatement
import org.jetbrains.kotlin.fir.symbols.ConeCallableSymbol import org.jetbrains.kotlin.fir.symbols.ConeCallableSymbol
import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.fir.types.FirTypeRef
import org.jetbrains.kotlin.fir.visitors.FirVisitor import org.jetbrains.kotlin.fir.visitors.FirVisitor
abstract class FirExpression( abstract class FirExpression(
session: FirSession,
psi: PsiElement? psi: PsiElement?
) : FirAnnotatedStatement(session, psi) { ) : FirAnnotatedStatement(psi) {
abstract val typeRef: FirTypeRef abstract val typeRef: FirTypeRef
abstract fun replaceTypeRef(newTypeRef: FirTypeRef) abstract fun replaceTypeRef(newTypeRef: FirTypeRef)
compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirFunctionCall.kt
+1 -2
View File
@@ -14,9 +14,8 @@ import org.jetbrains.kotlin.fir.types.FirTypeProjectionContainer
import org.jetbrains.kotlin.fir.visitors.FirVisitor import org.jetbrains.kotlin.fir.visitors.FirVisitor
abstract class FirFunctionCall( abstract class FirFunctionCall(
session: FirSession,
psi: PsiElement? psi: PsiElement?
) : @VisitedSupertype FirUnknownTypeCallWithArgumentList(session, psi), FirQualifiedAccess, FirTypeProjectionContainer { ) : @VisitedSupertype FirUnknownTypeCallWithArgumentList(psi), FirQualifiedAccess, FirTypeProjectionContainer {
abstract override val calleeReference: FirNamedReference abstract override val calleeReference: FirNamedReference
override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirGetClassCall.kt
+1 -5
View File
@@ -6,14 +6,10 @@
package org.jetbrains.kotlin.fir.expressions package org.jetbrains.kotlin.fir.expressions
import com.intellij.psi.PsiElement import com.intellij.psi.PsiElement
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.expressions.impl.FirUnknownTypeCallWithArgumentList import org.jetbrains.kotlin.fir.expressions.impl.FirUnknownTypeCallWithArgumentList
import org.jetbrains.kotlin.fir.visitors.FirVisitor import org.jetbrains.kotlin.fir.visitors.FirVisitor
abstract class FirGetClassCall( abstract class FirGetClassCall(psi: PsiElement?) : FirUnknownTypeCallWithArgumentList(psi) {
session: FirSession,
psi: PsiElement?
) : FirUnknownTypeCallWithArgumentList(session, psi) {
val argument: FirExpression get() = arguments.first() val argument: FirExpression get() = arguments.first()
override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirJump.kt
+1 -5
View File
@@ -6,15 +6,11 @@
package org.jetbrains.kotlin.fir.expressions package org.jetbrains.kotlin.fir.expressions
import com.intellij.psi.PsiElement import com.intellij.psi.PsiElement
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.FirTarget import org.jetbrains.kotlin.fir.FirTarget
import org.jetbrains.kotlin.fir.FirTargetElement import org.jetbrains.kotlin.fir.FirTargetElement
import org.jetbrains.kotlin.fir.visitors.FirVisitor import org.jetbrains.kotlin.fir.visitors.FirVisitor
abstract class FirJump<E : FirTargetElement>( abstract class FirJump<E : FirTargetElement>(psi: PsiElement?) : FirExpression(psi) {
session: FirSession,
psi: PsiElement?
) : FirExpression(session, psi) {
abstract val target: FirTarget<E> abstract val target: FirTarget<E>
override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirLambdaArgumentExpression.kt
+1 -5
View File
@@ -6,13 +6,9 @@
package org.jetbrains.kotlin.fir.expressions package org.jetbrains.kotlin.fir.expressions
import com.intellij.psi.PsiElement import com.intellij.psi.PsiElement
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.visitors.FirVisitor import org.jetbrains.kotlin.fir.visitors.FirVisitor
abstract class FirLambdaArgumentExpression( abstract class FirLambdaArgumentExpression(psi: PsiElement?) : FirWrappedArgumentExpression(psi) {
session: FirSession,
psi: PsiElement?
) : FirWrappedArgumentExpression(session, psi) {
override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
visitor.visitLambdaArgumentExpression(this, data) visitor.visitLambdaArgumentExpression(this, data)
} }
compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirNamedArgumentExpression.kt
+1 -3
View File
@@ -6,14 +6,12 @@
package org.jetbrains.kotlin.fir.expressions package org.jetbrains.kotlin.fir.expressions
import com.intellij.psi.PsiElement import com.intellij.psi.PsiElement
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.visitors.FirVisitor import org.jetbrains.kotlin.fir.visitors.FirVisitor
import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.name.Name
abstract class FirNamedArgumentExpression( abstract class FirNamedArgumentExpression(
session: FirSession,
psi: PsiElement? psi: PsiElement?
) : FirWrappedArgumentExpression(session, psi) { ) : FirWrappedArgumentExpression(psi) {
abstract val name: Name abstract val name: Name
override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirOperatorCall.kt
+1 -5
View File
@@ -6,14 +6,10 @@
package org.jetbrains.kotlin.fir.expressions package org.jetbrains.kotlin.fir.expressions
import com.intellij.psi.PsiElement import com.intellij.psi.PsiElement
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.expressions.impl.FirCallWithArgumentList import org.jetbrains.kotlin.fir.expressions.impl.FirCallWithArgumentList
import org.jetbrains.kotlin.fir.visitors.FirVisitor import org.jetbrains.kotlin.fir.visitors.FirVisitor
abstract class FirOperatorCall( abstract class FirOperatorCall(psi: PsiElement?) : FirCallWithArgumentList(psi) {
session: FirSession,
psi: PsiElement?
) : FirCallWithArgumentList(session, psi) {
abstract val operation: FirOperation abstract val operation: FirOperation
override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirQualifiedAccessExpression.kt
+1 -3
View File
@@ -6,15 +6,13 @@
package org.jetbrains.kotlin.fir.expressions package org.jetbrains.kotlin.fir.expressions
import com.intellij.psi.PsiElement import com.intellij.psi.PsiElement
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.VisitedSupertype import org.jetbrains.kotlin.fir.VisitedSupertype
import org.jetbrains.kotlin.fir.expressions.impl.FirUnknownTypeExpression import org.jetbrains.kotlin.fir.expressions.impl.FirUnknownTypeExpression
import org.jetbrains.kotlin.fir.visitors.FirVisitor import org.jetbrains.kotlin.fir.visitors.FirVisitor
abstract class FirQualifiedAccessExpression( abstract class FirQualifiedAccessExpression(
session: FirSession,
psi: PsiElement? psi: PsiElement?
) : FirQualifiedAccess, @VisitedSupertype FirUnknownTypeExpression(session, psi) { ) : FirQualifiedAccess, @VisitedSupertype FirUnknownTypeExpression(psi) {
override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
visitor.visitQualifiedAccessExpression(this, data) visitor.visitQualifiedAccessExpression(this, data)
compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirResolvedQualifier.kt
+1 -5
View File
@@ -6,16 +6,12 @@
package org.jetbrains.kotlin.fir.expressions package org.jetbrains.kotlin.fir.expressions
import com.intellij.psi.PsiElement import com.intellij.psi.PsiElement
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.expressions.impl.FirUnknownTypeExpression import org.jetbrains.kotlin.fir.expressions.impl.FirUnknownTypeExpression
import org.jetbrains.kotlin.fir.visitors.FirVisitor import org.jetbrains.kotlin.fir.visitors.FirVisitor
import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.ClassId
import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.FqName
abstract class FirResolvedQualifier( abstract class FirResolvedQualifier(psi: PsiElement?) : FirUnknownTypeExpression(psi) {
session: FirSession,
psi: PsiElement?
) : FirUnknownTypeExpression(session, psi) {
abstract val packageFqName: FqName abstract val packageFqName: FqName
abstract val relativeClassFqName: FqName? abstract val relativeClassFqName: FqName?
compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirReturnExpression.kt
+1 -5
View File
@@ -6,14 +6,10 @@
package org.jetbrains.kotlin.fir.expressions package org.jetbrains.kotlin.fir.expressions
import com.intellij.psi.PsiElement import com.intellij.psi.PsiElement
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.declarations.FirFunction import org.jetbrains.kotlin.fir.declarations.FirFunction
import org.jetbrains.kotlin.fir.visitors.FirVisitor import org.jetbrains.kotlin.fir.visitors.FirVisitor
abstract class FirReturnExpression( abstract class FirReturnExpression(psi: PsiElement?) : FirJump<FirFunction>(psi) {
session: FirSession,
psi: PsiElement?
) : FirJump<FirFunction>(session, psi) {
abstract val result: FirExpression abstract val result: FirExpression
override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirSpreadArgumentExpression.kt
+1 -5
View File
@@ -6,13 +6,9 @@
package org.jetbrains.kotlin.fir.expressions package org.jetbrains.kotlin.fir.expressions
import com.intellij.psi.PsiElement import com.intellij.psi.PsiElement
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.visitors.FirVisitor import org.jetbrains.kotlin.fir.visitors.FirVisitor
abstract class FirSpreadArgumentExpression( abstract class FirSpreadArgumentExpression(psi: PsiElement?) : FirWrappedArgumentExpression(psi) {
session: FirSession,
psi: PsiElement?
) : FirWrappedArgumentExpression(session, psi) {
override val isSpread: Boolean override val isSpread: Boolean
get() = true get() = true
compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirStringConcatenationCall.kt
+1 -5
View File
@@ -6,14 +6,10 @@
package org.jetbrains.kotlin.fir.expressions package org.jetbrains.kotlin.fir.expressions
import com.intellij.psi.PsiElement import com.intellij.psi.PsiElement
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.expressions.impl.FirCallWithArgumentList import org.jetbrains.kotlin.fir.expressions.impl.FirCallWithArgumentList
import org.jetbrains.kotlin.fir.visitors.FirVisitor import org.jetbrains.kotlin.fir.visitors.FirVisitor
abstract class FirStringConcatenationCall( abstract class FirStringConcatenationCall(psi: PsiElement?) : FirCallWithArgumentList(psi) {
session: FirSession,
psi: PsiElement?
) : FirCallWithArgumentList(session, psi) {
override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
visitor.visitStringConcatenationCall(this, data) visitor.visitStringConcatenationCall(this, data)
} }
compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirThrowExpression.kt
+1 -5
View File
@@ -6,13 +6,9 @@
package org.jetbrains.kotlin.fir.expressions package org.jetbrains.kotlin.fir.expressions
import com.intellij.psi.PsiElement import com.intellij.psi.PsiElement
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.visitors.FirVisitor import org.jetbrains.kotlin.fir.visitors.FirVisitor
abstract class FirThrowExpression( abstract class FirThrowExpression(psi: PsiElement?) : FirExpression(psi) {
session: FirSession,
psi: PsiElement?
) : FirExpression(session, psi) {
abstract val exception: FirExpression abstract val exception: FirExpression
override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirTryExpression.kt
+1 -3
View File
@@ -6,14 +6,12 @@
package org.jetbrains.kotlin.fir.expressions package org.jetbrains.kotlin.fir.expressions
import com.intellij.psi.PsiElement import com.intellij.psi.PsiElement
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.expressions.impl.FirUnknownTypeExpression import org.jetbrains.kotlin.fir.expressions.impl.FirUnknownTypeExpression
import org.jetbrains.kotlin.fir.visitors.FirVisitor import org.jetbrains.kotlin.fir.visitors.FirVisitor
abstract class FirTryExpression( abstract class FirTryExpression(
session: FirSession,
psi: PsiElement? psi: PsiElement?
) : FirUnknownTypeExpression(session, psi) { ) : FirUnknownTypeExpression(psi) {
abstract val tryBlock: FirBlock abstract val tryBlock: FirBlock
abstract val catches: List<FirCatch> abstract val catches: List<FirCatch>
compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirTypeOperatorCall.kt
+1 -3
View File
@@ -6,17 +6,15 @@
package org.jetbrains.kotlin.fir.expressions package org.jetbrains.kotlin.fir.expressions
import com.intellij.psi.PsiElement import com.intellij.psi.PsiElement
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.expressions.impl.FirOperationBasedCall import org.jetbrains.kotlin.fir.expressions.impl.FirOperationBasedCall
import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.fir.types.FirTypeRef
import org.jetbrains.kotlin.fir.visitors.FirVisitor import org.jetbrains.kotlin.fir.visitors.FirVisitor
// is/!is/as/as? // is/!is/as/as?
abstract class FirTypeOperatorCall( abstract class FirTypeOperatorCall(
session: FirSession,
psi: PsiElement?, psi: PsiElement?,
operation: FirOperation operation: FirOperation
) : FirOperationBasedCall(session, psi, operation) { ) : FirOperationBasedCall(psi, operation) {
val argument: FirExpression get() = arguments.first() val argument: FirExpression get() = arguments.first()
abstract val conversionTypeRef: FirTypeRef abstract val conversionTypeRef: FirTypeRef
compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirUncheckedNotNullCast.kt
+1 -5
View File
@@ -6,14 +6,10 @@
package org.jetbrains.kotlin.fir.expressions package org.jetbrains.kotlin.fir.expressions
import com.intellij.psi.PsiElement import com.intellij.psi.PsiElement
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.expressions.impl.FirUnknownTypeCallWithArgumentList import org.jetbrains.kotlin.fir.expressions.impl.FirUnknownTypeCallWithArgumentList
import org.jetbrains.kotlin.fir.visitors.FirVisitor import org.jetbrains.kotlin.fir.visitors.FirVisitor
abstract class FirUncheckedNotNullCast( abstract class FirUncheckedNotNullCast(psi: PsiElement?) : FirUnknownTypeCallWithArgumentList(psi) {
session: FirSession,
psi: PsiElement?
) : FirUnknownTypeCallWithArgumentList(session, psi) {
override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitUncheckedNotNullCast(this, data) override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitUncheckedNotNullCast(this, data)
val expression: FirExpression get() = arguments[0] val expression: FirExpression get() = arguments[0]
compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirWhenExpression.kt
+1 -5
View File
@@ -6,14 +6,10 @@
package org.jetbrains.kotlin.fir.expressions package org.jetbrains.kotlin.fir.expressions
import com.intellij.psi.PsiElement import com.intellij.psi.PsiElement
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.expressions.impl.FirUnknownTypeExpression import org.jetbrains.kotlin.fir.expressions.impl.FirUnknownTypeExpression
import org.jetbrains.kotlin.fir.visitors.FirVisitor import org.jetbrains.kotlin.fir.visitors.FirVisitor
abstract class FirWhenExpression( abstract class FirWhenExpression(psi: PsiElement?) : FirUnknownTypeExpression(psi) {
session: FirSession,
psi: PsiElement?
) : FirUnknownTypeExpression(session, psi) {
abstract val subject: FirExpression? abstract val subject: FirExpression?
// when (val subjectVariable = subject()) { ... } // when (val subjectVariable = subject()) { ... }
compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirWhenSubjectExpression.kt
+1 -5
View File
@@ -6,15 +6,11 @@
package org.jetbrains.kotlin.fir.expressions package org.jetbrains.kotlin.fir.expressions
import com.intellij.psi.PsiElement import com.intellij.psi.PsiElement
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.FirWhenSubject import org.jetbrains.kotlin.fir.FirWhenSubject
import org.jetbrains.kotlin.fir.expressions.impl.FirUnknownTypeExpression import org.jetbrains.kotlin.fir.expressions.impl.FirUnknownTypeExpression
import org.jetbrains.kotlin.fir.visitors.FirVisitor import org.jetbrains.kotlin.fir.visitors.FirVisitor
abstract class FirWhenSubjectExpression( abstract class FirWhenSubjectExpression(psi: PsiElement?) : FirUnknownTypeExpression(psi) {
session: FirSession,
psi: PsiElement?
) : FirUnknownTypeExpression(session, psi) {
abstract val whenSubject: FirWhenSubject abstract val whenSubject: FirWhenSubject
override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirWrappedArgumentExpression.kt
+1 -5
View File
@@ -6,14 +6,10 @@
package org.jetbrains.kotlin.fir.expressions package org.jetbrains.kotlin.fir.expressions
import com.intellij.psi.PsiElement import com.intellij.psi.PsiElement
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.fir.types.FirTypeRef
import org.jetbrains.kotlin.fir.visitors.FirVisitor import org.jetbrains.kotlin.fir.visitors.FirVisitor
abstract class FirWrappedArgumentExpression( abstract class FirWrappedArgumentExpression(psi: PsiElement?) : FirWrappedExpression(psi) {
session: FirSession,
psi: PsiElement?
) : FirWrappedExpression(session, psi) {
open val isSpread: Boolean open val isSpread: Boolean
get() = false get() = false
compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirWrappedDelegateExpression.kt
+1 -5
View File
@@ -6,14 +6,10 @@
package org.jetbrains.kotlin.fir.expressions package org.jetbrains.kotlin.fir.expressions
import com.intellij.psi.PsiElement import com.intellij.psi.PsiElement
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.fir.types.FirTypeRef
import org.jetbrains.kotlin.fir.visitors.FirVisitor import org.jetbrains.kotlin.fir.visitors.FirVisitor
abstract class FirWrappedDelegateExpression( abstract class FirWrappedDelegateExpression(psi: PsiElement?) : FirWrappedExpression(psi) {
session: FirSession,
psi: PsiElement?
) : FirWrappedExpression(session, psi) {
abstract val delegateProvider: FirExpression abstract val delegateProvider: FirExpression
override val typeRef: FirTypeRef override val typeRef: FirTypeRef
compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirWrappedExpression.kt
+1 -5
View File
@@ -6,14 +6,10 @@
package org.jetbrains.kotlin.fir.expressions package org.jetbrains.kotlin.fir.expressions
import com.intellij.psi.PsiElement import com.intellij.psi.PsiElement
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.fir.types.FirTypeRef
import org.jetbrains.kotlin.fir.visitors.FirVisitor import org.jetbrains.kotlin.fir.visitors.FirVisitor
abstract class FirWrappedExpression( abstract class FirWrappedExpression(psi: PsiElement?) : FirExpression(psi) {
session: FirSession,
psi: PsiElement?
) : FirExpression(session, psi) {
abstract val expression: FirExpression abstract val expression: FirExpression
override fun replaceTypeRef(newTypeRef: FirTypeRef) { override fun replaceTypeRef(newTypeRef: FirTypeRef) {
compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirAbstractAnnotatedElement.kt
+1 -5
View File
@@ -8,16 +8,12 @@ package org.jetbrains.kotlin.fir.expressions.impl
import com.intellij.psi.PsiElement import com.intellij.psi.PsiElement
import org.jetbrains.kotlin.fir.FirAbstractElement import org.jetbrains.kotlin.fir.FirAbstractElement
import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.FirElement
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
import org.jetbrains.kotlin.fir.expressions.FirAnnotationContainer import org.jetbrains.kotlin.fir.expressions.FirAnnotationContainer
import org.jetbrains.kotlin.fir.transformInplace import org.jetbrains.kotlin.fir.transformInplace
import org.jetbrains.kotlin.fir.visitors.FirTransformer import org.jetbrains.kotlin.fir.visitors.FirTransformer
abstract class FirAbstractAnnotatedElement( abstract class FirAbstractAnnotatedElement(psi: PsiElement?) : FirAbstractElement(psi), FirAnnotationContainer {
session: FirSession,
psi: PsiElement?
) : FirAbstractElement(session, psi), FirAnnotationContainer {
final override val annotations = mutableListOf<FirAnnotationCall>() final override val annotations = mutableListOf<FirAnnotationCall>()
override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement { override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirAbstractAssignment.kt
+1 -3
View File
@@ -8,7 +8,6 @@ package org.jetbrains.kotlin.fir.expressions.impl
import com.intellij.psi.PsiElement import com.intellij.psi.PsiElement
import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.FirElement
import org.jetbrains.kotlin.fir.FirReference import org.jetbrains.kotlin.fir.FirReference
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.expressions.FirAssignment import org.jetbrains.kotlin.fir.expressions.FirAssignment
import org.jetbrains.kotlin.fir.expressions.FirExpression import org.jetbrains.kotlin.fir.expressions.FirExpression
import org.jetbrains.kotlin.fir.expressions.FirOperation import org.jetbrains.kotlin.fir.expressions.FirOperation
@@ -17,12 +16,11 @@ import org.jetbrains.kotlin.fir.transformSingle
import org.jetbrains.kotlin.fir.visitors.FirTransformer import org.jetbrains.kotlin.fir.visitors.FirTransformer
abstract class FirAbstractAssignment( abstract class FirAbstractAssignment(
session: FirSession,
psi: PsiElement?, psi: PsiElement?,
final override var rValue: FirExpression, final override var rValue: FirExpression,
final override val operation: FirOperation, final override val operation: FirOperation,
safe: Boolean = false safe: Boolean = false
) : FirAbstractQualifiedAccess(session, psi, safe), FirVariableAssignment { ) : FirAbstractQualifiedAccess(psi, safe), FirVariableAssignment {
override var lValue: FirReference override var lValue: FirReference
get() = calleeReference get() = calleeReference
compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirAbstractLoop.kt
+1 -2
View File
@@ -13,10 +13,9 @@ import org.jetbrains.kotlin.fir.expressions.FirLoop
import org.jetbrains.kotlin.fir.visitors.FirTransformer import org.jetbrains.kotlin.fir.visitors.FirTransformer
abstract class FirAbstractLoop( abstract class FirAbstractLoop(
session: FirSession,
psi: PsiElement?, psi: PsiElement?,
override var condition: FirExpression override var condition: FirExpression
) : FirAnnotatedStatement(session, psi), FirLoop { ) : FirAnnotatedStatement(psi), FirLoop {
override lateinit var block: FirBlock override lateinit var block: FirBlock
override var label: FirLabel? = null override var label: FirLabel? = null
compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirAbstractQualifiedAccess.kt
+1 -2
View File
@@ -12,10 +12,9 @@ import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccess
import org.jetbrains.kotlin.fir.visitors.FirTransformer import org.jetbrains.kotlin.fir.visitors.FirTransformer
abstract class FirAbstractQualifiedAccess( abstract class FirAbstractQualifiedAccess(
session: FirSession,
psi: PsiElement?, psi: PsiElement?,
final override var safe: Boolean = false final override var safe: Boolean = false
) : FirAnnotatedStatement(session, psi), FirModifiableQualifiedAccess<FirReference> { ) : FirAnnotatedStatement(psi), FirModifiableQualifiedAccess<FirReference> {
final override lateinit var calleeReference: FirReference final override lateinit var calleeReference: FirReference
final override var explicitReceiver: FirExpression? = null final override var explicitReceiver: FirExpression? = null
compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirAnnotatedStatement.kt
+1 -5
View File
@@ -6,10 +6,6 @@
package org.jetbrains.kotlin.fir.expressions.impl package org.jetbrains.kotlin.fir.expressions.impl
import com.intellij.psi.PsiElement import com.intellij.psi.PsiElement
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.expressions.FirStatement import org.jetbrains.kotlin.fir.expressions.FirStatement
abstract class FirAnnotatedStatement( abstract class FirAnnotatedStatement(psi: PsiElement?) : FirAbstractAnnotatedElement(psi), FirStatement
session: FirSession,
psi: PsiElement?
) : FirAbstractAnnotatedElement(session, psi), FirStatement
compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirAnnotationCallImpl.kt
+1 -3
View File
@@ -8,18 +8,16 @@ package org.jetbrains.kotlin.fir.expressions.impl
import com.intellij.psi.PsiElement import com.intellij.psi.PsiElement
import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.FirElement
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
import org.jetbrains.kotlin.fir.transformSingle import org.jetbrains.kotlin.fir.transformSingle
import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.fir.types.FirTypeRef
import org.jetbrains.kotlin.fir.visitors.FirTransformer import org.jetbrains.kotlin.fir.visitors.FirTransformer
class FirAnnotationCallImpl( class FirAnnotationCallImpl(
session: FirSession,
psi: PsiElement?, psi: PsiElement?,
override val useSiteTarget: AnnotationUseSiteTarget?, override val useSiteTarget: AnnotationUseSiteTarget?,
override var annotationTypeRef: FirTypeRef override var annotationTypeRef: FirTypeRef
) : FirAnnotationCall(session, psi) { ) : FirAnnotationCall(psi) {
override val typeRef: FirTypeRef override val typeRef: FirTypeRef
get() = annotationTypeRef get() = annotationTypeRef
compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirArrayOfCallImpl.kt
+1 -5
View File
@@ -6,10 +6,6 @@
package org.jetbrains.kotlin.fir.expressions.impl package org.jetbrains.kotlin.fir.expressions.impl
import com.intellij.psi.PsiElement import com.intellij.psi.PsiElement
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.expressions.FirArrayOfCall import org.jetbrains.kotlin.fir.expressions.FirArrayOfCall
class FirArrayOfCallImpl( class FirArrayOfCallImpl(psi: PsiElement?) : FirArrayOfCall(psi)
session: FirSession,
psi: PsiElement?
) : FirArrayOfCall(session, psi)
compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirArraySetCallImpl.kt
+2 -3
View File
@@ -13,11 +13,10 @@ import org.jetbrains.kotlin.fir.types.impl.FirImplicitTypeRefImpl
import org.jetbrains.kotlin.fir.visitors.FirTransformer import org.jetbrains.kotlin.fir.visitors.FirTransformer
class FirArraySetCallImpl( class FirArraySetCallImpl(
session: FirSession,
psi: PsiElement?, psi: PsiElement?,
override var rValue: FirExpression, override var rValue: FirExpression,
override val operation: FirOperation override val operation: FirOperation
) : FirArraySetCall(session, psi), FirModifiableQualifiedAccess<FirReference> { ) : FirArraySetCall(psi), FirModifiableQualifiedAccess<FirReference> {
override lateinit var calleeReference: FirReference override lateinit var calleeReference: FirReference
override var lValue: FirReference override var lValue: FirReference
@@ -30,7 +29,7 @@ class FirArraySetCallImpl(
get() = null get() = null
set(_) {} set(_) {}
override var typeRef: FirTypeRef = FirImplicitTypeRefImpl(session, null) override var typeRef: FirTypeRef = FirImplicitTypeRefImpl(null)
override fun replaceTypeRef(newTypeRef: FirTypeRef) { override fun replaceTypeRef(newTypeRef: FirTypeRef) {
typeRef = newTypeRef typeRef = newTypeRef
compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirBlockImpl.kt
+1 -5
View File
@@ -7,16 +7,12 @@ package org.jetbrains.kotlin.fir.expressions.impl
import com.intellij.psi.PsiElement import com.intellij.psi.PsiElement
import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.FirElement
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.expressions.FirBlock import org.jetbrains.kotlin.fir.expressions.FirBlock
import org.jetbrains.kotlin.fir.expressions.FirStatement import org.jetbrains.kotlin.fir.expressions.FirStatement
import org.jetbrains.kotlin.fir.transformInplace import org.jetbrains.kotlin.fir.transformInplace
import org.jetbrains.kotlin.fir.visitors.FirTransformer import org.jetbrains.kotlin.fir.visitors.FirTransformer
class FirBlockImpl( class FirBlockImpl(psi: PsiElement?) : FirBlock(psi) {
session: FirSession,
psi: PsiElement?
) : FirBlock(session, psi) {
override val statements = mutableListOf<FirStatement>() override val statements = mutableListOf<FirStatement>()
override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement { override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirBreakExpressionImpl.kt
+1 -5
View File
@@ -6,10 +6,6 @@
package org.jetbrains.kotlin.fir.expressions.impl package org.jetbrains.kotlin.fir.expressions.impl
import com.intellij.psi.PsiElement import com.intellij.psi.PsiElement
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.expressions.FirBreakExpression import org.jetbrains.kotlin.fir.expressions.FirBreakExpression
class FirBreakExpressionImpl( class FirBreakExpressionImpl(psi: PsiElement?) : FirBreakExpression(psi)
session: FirSession,
psi: PsiElement?
) : FirBreakExpression(session, psi)
compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirCallWithArgumentList.kt
+1 -5
View File
@@ -7,16 +7,12 @@ package org.jetbrains.kotlin.fir.expressions.impl
import com.intellij.psi.PsiElement import com.intellij.psi.PsiElement
import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.FirElement
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.expressions.FirCall import org.jetbrains.kotlin.fir.expressions.FirCall
import org.jetbrains.kotlin.fir.expressions.FirExpression import org.jetbrains.kotlin.fir.expressions.FirExpression
import org.jetbrains.kotlin.fir.transformInplace import org.jetbrains.kotlin.fir.transformInplace
import org.jetbrains.kotlin.fir.visitors.FirTransformer import org.jetbrains.kotlin.fir.visitors.FirTransformer
abstract class FirCallWithArgumentList( abstract class FirCallWithArgumentList(psi: PsiElement?) : FirCall(psi) {
session: FirSession,
psi: PsiElement?
) : FirCall(session, psi) {
override val arguments = mutableListOf<FirExpression>() override val arguments = mutableListOf<FirExpression>()
override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement { override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirCallableReferenceAccessImpl.kt
+1 -3
View File
@@ -8,16 +8,14 @@ package org.jetbrains.kotlin.fir.expressions.impl
import com.intellij.psi.PsiElement import com.intellij.psi.PsiElement
import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.FirElement
import org.jetbrains.kotlin.fir.FirReference import org.jetbrains.kotlin.fir.FirReference
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.expressions.FirCallableReferenceAccess import org.jetbrains.kotlin.fir.expressions.FirCallableReferenceAccess
import org.jetbrains.kotlin.fir.expressions.FirExpression import org.jetbrains.kotlin.fir.expressions.FirExpression
import org.jetbrains.kotlin.fir.transformSingle import org.jetbrains.kotlin.fir.transformSingle
import org.jetbrains.kotlin.fir.visitors.FirTransformer import org.jetbrains.kotlin.fir.visitors.FirTransformer
class FirCallableReferenceAccessImpl( class FirCallableReferenceAccessImpl(
session: FirSession,
psi: PsiElement? psi: PsiElement?
) : FirCallableReferenceAccess(session, psi), FirModifiableQualifiedAccess<FirReference> { ) : FirCallableReferenceAccess(psi), FirModifiableQualifiedAccess<FirReference> {
override lateinit var calleeReference: FirReference override lateinit var calleeReference: FirReference
override var explicitReceiver: FirExpression? = null override var explicitReceiver: FirExpression? = null
compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirCatchImpl.kt
+1 -3
View File
@@ -8,7 +8,6 @@ package org.jetbrains.kotlin.fir.expressions.impl
import com.intellij.psi.PsiElement import com.intellij.psi.PsiElement
import org.jetbrains.kotlin.fir.FirAbstractElement import org.jetbrains.kotlin.fir.FirAbstractElement
import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.FirElement
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.declarations.FirValueParameter import org.jetbrains.kotlin.fir.declarations.FirValueParameter
import org.jetbrains.kotlin.fir.expressions.FirBlock import org.jetbrains.kotlin.fir.expressions.FirBlock
import org.jetbrains.kotlin.fir.expressions.FirCatch import org.jetbrains.kotlin.fir.expressions.FirCatch
@@ -16,11 +15,10 @@ import org.jetbrains.kotlin.fir.transformSingle
import org.jetbrains.kotlin.fir.visitors.FirTransformer import org.jetbrains.kotlin.fir.visitors.FirTransformer
class FirCatchImpl( class FirCatchImpl(
session: FirSession,
psi: PsiElement?, psi: PsiElement?,
override var parameter: FirValueParameter, override var parameter: FirValueParameter,
override var block: FirBlock override var block: FirBlock
) : FirAbstractElement(session, psi), FirCatch { ) : FirAbstractElement(psi), FirCatch {
override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement { override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
parameter = parameter.transformSingle(transformer, data) parameter = parameter.transformSingle(transformer, data)
block = block.transformSingle(transformer, data) block = block.transformSingle(transformer, data)

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