diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrVisitor.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrVisitor.kt index c910a3e6352..ff1bca4bdd9 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrVisitor.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrVisitor.kt @@ -73,13 +73,13 @@ internal class Fir2IrVisitor( 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 = getPackage(file.packageFqName).fragments.first() diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaSymbolProvider.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaSymbolProvider.kt index c2ba92c6e05..98ad3f78f44 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaSymbolProvider.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaSymbolProvider.kt @@ -219,7 +219,7 @@ class JavaSymbolProvider( val firJavaConstructor = FirJavaConstructor( this@JavaSymbolProvider.session, constructorSymbol, visibility, isPrimary, FirResolvedTypeRefImpl( - this@JavaSymbolProvider.session, null, + null, firSymbol.constructType( classTypeParameters.map { ConeTypeParameterTypeImpl(it.symbol.toLookupTag(), false) }.toTypedArray(), false diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaUtils.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaUtils.kt index 1c464104764..440264ef836 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaUtils.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaUtils.kt @@ -81,8 +81,8 @@ internal fun JavaType?.toNotNullConeKotlinType( internal fun JavaType.toFirJavaTypeRef(session: FirSession, javaTypeParameterStack: JavaTypeParameterStack): FirJavaTypeRef { val annotations = (this as? JavaClassifierType)?.annotations.orEmpty() return FirJavaTypeRef( - session, - annotations = annotations.map { it.toFirAnnotationCall(session, javaTypeParameterStack) }, type = this + annotations = annotations.map { it.toFirAnnotationCall(session, javaTypeParameterStack) }, + type = this ) } @@ -91,7 +91,7 @@ internal fun JavaClassifierType.toFirResolvedTypeRef( ): FirResolvedTypeRef { val coneType = this.toConeKotlinTypeWithNullability(session, javaTypeParameterStack, isNullable = false) return FirResolvedTypeRefImpl( - session, psi = null, type = coneType, + psi = null, type = coneType, annotations = annotations.map { it.toFirAnnotationCall(session, javaTypeParameterStack) } ) } @@ -170,9 +170,8 @@ internal fun JavaAnnotation.toFirAnnotationCall( session: FirSession, javaTypeParameterStack: JavaTypeParameterStack ): FirAnnotationCall { return FirAnnotationCallImpl( - session, psi = null, useSiteTarget = null, + psi = null, useSiteTarget = null, annotationTypeRef = FirResolvedTypeRefImpl( - session, psi = null, type = ConeClassTypeImpl(FirClassSymbol(classId!!).toLookupTag(), emptyArray(), isNullable = false), annotations = emptyList() @@ -237,13 +236,13 @@ private fun JavaAnnotationArgument.toFirExpression( is JavaLiteralAnnotationArgument -> { value.createConstant(session) } - is JavaArrayAnnotationArgument -> FirArrayOfCallImpl(session, null).apply { + is JavaArrayAnnotationArgument -> FirArrayOfCallImpl(null).apply { for (element in getElements()) { arguments += element.toFirExpression(session, javaTypeParameterStack) } } is JavaEnumValueAnnotationArgument -> { - FirFunctionCallImpl(session, null).apply { + FirFunctionCallImpl(null).apply { val classId = this@toFirExpression.enumClassId val entryName = this@toFirExpression.entryName val calleeReference = if (classId != null && entryName != null) { @@ -251,29 +250,29 @@ private fun JavaAnnotationArgument.toFirExpression( classId, entryName ).firstOrNull() callableSymbol?.let { - FirResolvedCallableReferenceImpl(session, null, entryName, it) + FirResolvedCallableReferenceImpl(null, entryName, it) } } else { null } 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() arguments += FirClassReferenceExpressionImpl( - session, null, referencedType.toFirResolvedTypeRef(session, javaTypeParameterStack) + null, referencedType.toFirResolvedTypeRef(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 private fun List.createArrayOfCall(session: FirSession, @Suppress("UNUSED_PARAMETER") kind: IrConstKind): FirArrayOfCall { - return FirArrayOfCallImpl(session, null).apply { + return FirArrayOfCallImpl(null).apply { for (element in this@createArrayOfCall) { arguments += element.createConstant(session) } @@ -282,15 +281,15 @@ private fun List.createArrayOfCall(session: FirSession, @Suppress("UNUSED internal fun Any?.createConstant(session: FirSession): FirExpression { return when (this) { - is Byte -> FirConstExpressionImpl(session, null, IrConstKind.Byte, this) - is Short -> FirConstExpressionImpl(session, null, IrConstKind.Short, this) - is Int -> FirConstExpressionImpl(session, null, IrConstKind.Int, this) - is Long -> FirConstExpressionImpl(session, null, IrConstKind.Long, this) - is Char -> FirConstExpressionImpl(session, null, IrConstKind.Char, this) - is Float -> FirConstExpressionImpl(session, null, IrConstKind.Float, this) - is Double -> FirConstExpressionImpl(session, null, IrConstKind.Double, this) - is Boolean -> FirConstExpressionImpl(session, null, IrConstKind.Boolean, this) - is String -> FirConstExpressionImpl(session, null, IrConstKind.String, this) + is Byte -> FirConstExpressionImpl(null, IrConstKind.Byte, this) + is Short -> FirConstExpressionImpl(null, IrConstKind.Short, this) + is Int -> FirConstExpressionImpl(null, IrConstKind.Int, this) + is Long -> FirConstExpressionImpl(null, IrConstKind.Long, this) + is Char -> FirConstExpressionImpl(null, IrConstKind.Char, this) + is Float -> FirConstExpressionImpl(null, IrConstKind.Float, this) + is Double -> FirConstExpressionImpl(null, IrConstKind.Double, this) + is Boolean -> FirConstExpressionImpl(null, IrConstKind.Boolean, this) + is String -> FirConstExpressionImpl(null, IrConstKind.String, this) is ByteArray -> toList().createArrayOfCall(session, IrConstKind.Byte) is ShortArray -> toList().createArrayOfCall(session, IrConstKind.Short) 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 DoubleArray -> toList().createArrayOfCall(session, IrConstKind.Double) 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 { if (this is JavaClassifierType) return toFirResolvedTypeRef(session, javaTypeParameterStack) return FirResolvedTypeRefImpl( - session, psi = null, type = ConeClassErrorType("Unexpected JavaType: $this"), + psi = null, type = ConeClassErrorType("Unexpected JavaType: $this"), annotations = emptyList() ) } diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/deserialization/KotlinDeserializedJvmSymbolsProvider.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/deserialization/KotlinDeserializedJvmSymbolsProvider.kt index 62e1d0721f5..cb0c73af930 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/deserialization/KotlinDeserializedJvmSymbolsProvider.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/deserialization/KotlinDeserializedJvmSymbolsProvider.kt @@ -176,10 +176,10 @@ class KotlinDeserializedJvmSymbolsProvider( private fun ConeClassifierSymbol?.toDefaultResolvedTypeRef(classId: ClassId): FirResolvedTypeRef { return this?.let { FirResolvedTypeRefImpl( - session, null, it.constructType(emptyList(), isNullable = false), + null, it.constructType(emptyList(), isNullable = false), 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 literalSymbol = literalLookupTag.toSymbol(this@KotlinDeserializedJvmSymbolsProvider.session) return FirClassReferenceExpressionImpl( - this@KotlinDeserializedJvmSymbolsProvider.session, null, + null, literalSymbol.toDefaultResolvedTypeRef(classId) ) } private fun ClassId.toEnumEntryReferenceExpression(name: Name): FirExpression { - return FirFunctionCallImpl(session, null).apply { + return FirFunctionCallImpl(null).apply { val entryClassId = createNestedClassId(name) val entryLookupTag = ConeClassLikeLookupTagImpl(entryClassId) val entryClassSymbol = entryLookupTag.toSymbol(this@KotlinDeserializedJvmSymbolsProvider.session) @@ -220,17 +220,17 @@ class KotlinDeserializedJvmSymbolsProvider( this.calleeReference = when { entryClassSymbol != null && (entryClassSymbol as? FirClassSymbol)?.fir is FirEnumEntry -> { FirResolvedCallableReferenceImpl( - this@KotlinDeserializedJvmSymbolsProvider.session, null, name, entryClassSymbol + null, name, entryClassSymbol ) } entryCallableSymbol != null -> { FirResolvedCallableReferenceImpl( - this@KotlinDeserializedJvmSymbolsProvider.session, null, name, entryCallableSymbol + null, name, entryCallableSymbol ) } else -> { FirErrorNamedReference( - this@KotlinDeserializedJvmSymbolsProvider.session, null, + null, errorReason = "Strange deserialized enum value: ${this@toEnumEntryReferenceExpression}.$name" ) } @@ -239,7 +239,7 @@ class KotlinDeserializedJvmSymbolsProvider( } override fun visitClassLiteral(name: Name, value: ClassLiteralValue) { - argumentMap[name] = FirGetClassCallImpl(session, null).apply { + argumentMap[name] = FirGetClassCallImpl(null).apply { arguments += value.toFirClassReferenceExpression() } } @@ -265,7 +265,7 @@ class KotlinDeserializedJvmSymbolsProvider( } override fun visitEnd() { - argumentMap[name] = FirArrayOfCallImpl(session, null).apply { + argumentMap[name] = FirArrayOfCallImpl(null).apply { arguments += elements } } @@ -284,10 +284,10 @@ class KotlinDeserializedJvmSymbolsProvider( } 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) { arguments += FirNamedArgumentExpressionImpl( - this@KotlinDeserializedJvmSymbolsProvider.session, null, name, false, expression + null, name, false, expression ) } } diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/javaTypeUtils.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/javaTypeUtils.kt index b030f590a50..c8028f7815a 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/javaTypeUtils.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/javaTypeUtils.kt @@ -82,14 +82,14 @@ private fun JavaType?.enhancePossiblyFlexible( ) FirResolvedTypeRefImpl( - session, psi = null, + psi = null, type = coneFlexibleOrSimpleType(session, lowerResult, upperResult), annotations = annotations ) } else -> { 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 firEnumEntry = firElement.declarations.filterIsInstance().find { it.name == name } - return if (firEnumEntry != null) FirQualifiedAccessExpressionImpl(session, null).apply { + return if (firEnumEntry != null) FirQualifiedAccessExpressionImpl(null).apply { calleeReference = FirSimpleNamedReference( - session, null, name // TODO: , firEnumEntry.symbol + null, name // TODO: , firEnumEntry.symbol ) } else if (firElement is FirJavaClass) { val firStaticProperty = firElement.declarations.filterIsInstance().find { it.isStatic && it.modality == Modality.FINAL && it.name == name } if (firStaticProperty != null) { - FirQualifiedAccessExpressionImpl(session, null).apply { + FirQualifiedAccessExpressionImpl(null).apply { calleeReference = FirResolvedCallableReferenceImpl( - session, null, name, firStaticProperty.symbol as ConeCallableSymbol + null, name, firStaticProperty.symbol as ConeCallableSymbol ) } } else null @@ -269,15 +269,15 @@ internal fun ConeKotlinType.lexicalCastFrom(session: FirSession, value: String): val (number, radix) = extractRadix(value) return when (classId.relativeClassName.asString()) { - "Boolean" -> FirConstExpressionImpl(session, null, IrConstKind.Boolean, value.toBoolean()) - "Char" -> FirConstExpressionImpl(session, null, IrConstKind.Char, value.singleOrNull() ?: return null) - "Byte" -> FirConstExpressionImpl(session, null, IrConstKind.Byte, number.toByteOrNull(radix) ?: return null) - "Short" -> FirConstExpressionImpl(session, null, IrConstKind.Short, number.toShortOrNull(radix) ?: return null) - "Int" -> FirConstExpressionImpl(session, null, IrConstKind.Int, number.toIntOrNull(radix) ?: return null) - "Long" -> FirConstExpressionImpl(session, null, IrConstKind.Long, number.toLongOrNull(radix) ?: return null) - "Float" -> FirConstExpressionImpl(session, null, IrConstKind.Float, value.toFloatOrNull() ?: return null) - "Double" -> FirConstExpressionImpl(session, null, IrConstKind.Double, value.toDoubleOrNull() ?: return null) - "String" -> FirConstExpressionImpl(session, null, IrConstKind.String, value) + "Boolean" -> FirConstExpressionImpl(null, IrConstKind.Boolean, value.toBoolean()) + "Char" -> FirConstExpressionImpl(null, IrConstKind.Char, value.singleOrNull() ?: return null) + "Byte" -> FirConstExpressionImpl(null, IrConstKind.Byte, number.toByteOrNull(radix) ?: return null) + "Short" -> FirConstExpressionImpl(null, IrConstKind.Short, number.toShortOrNull(radix) ?: return null) + "Int" -> FirConstExpressionImpl(null, IrConstKind.Int, number.toIntOrNull(radix) ?: return null) + "Long" -> FirConstExpressionImpl(null, IrConstKind.Long, number.toLongOrNull(radix) ?: return null) + "Float" -> FirConstExpressionImpl(null, IrConstKind.Float, value.toFloatOrNull() ?: return null) + "Double" -> FirConstExpressionImpl(null, IrConstKind.Double, value.toDoubleOrNull() ?: return null) + "String" -> FirConstExpressionImpl(null, IrConstKind.String, value) else -> null } } diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/scopes/JavaClassEnhancementScope.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/scopes/JavaClassEnhancementScope.kt index 19ea090e7fe..015b0f2afeb 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/scopes/JavaClassEnhancementScope.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/scopes/JavaClassEnhancementScope.kt @@ -302,7 +302,7 @@ class JavaClassEnhancementScope( ).enhance(session, jsr305State, predefinedEnhancementInfo?.parametersInfo?.getOrNull(index)) val firResolvedTypeRef = signatureParts.type 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) null -> null } diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/types/FirJavaTypeRef.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/types/FirJavaTypeRef.kt index cc3a36dba22..dc84e7815f8 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/types/FirJavaTypeRef.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/types/FirJavaTypeRef.kt @@ -5,16 +5,14 @@ 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.types.impl.FirUserTypeRefImpl import org.jetbrains.kotlin.load.java.structure.JavaType class FirJavaTypeRef( - session: FirSession, annotations: List, val type: JavaType -) : FirUserTypeRefImpl(session, psi = null, isMarkedNullable = false) { +) : FirUserTypeRefImpl(psi = null, isMarkedNullable = false) { init { this.annotations += annotations } diff --git a/compiler/fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/ConversionUtils.kt b/compiler/fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/ConversionUtils.kt index a6514e45fbb..c62b6dbd510 100644 --- a/compiler/fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/ConversionUtils.kt +++ b/compiler/fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/ConversionUtils.kt @@ -102,7 +102,7 @@ internal fun translateEscape(c: Char): Char? = else -> null } -internal fun generateConstantExpressionByLiteral(session: FirSession, expression: KtConstantExpression): FirExpression { +internal fun generateConstantExpressionByLiteral(expression: KtConstantExpression): FirExpression { val type = expression.node.elementType val text: String = expression.text val convertedText: Any? = when (type) { @@ -117,32 +117,32 @@ internal fun generateConstantExpressionByLiteral(session: FirSession, expression convertedText > Int.MAX_VALUE || convertedText < Int.MIN_VALUE) ) { FirConstExpressionImpl( - session, expression, IrConstKind.Long, convertedText, "Incorrect long: $text" + expression, IrConstKind.Long, convertedText, "Incorrect long: $text" ) } else if (convertedText is Number) { // TODO: support byte / short - FirConstExpressionImpl(session, expression, IrConstKind.Int, convertedText.toInt(), "Incorrect int: $text") + FirConstExpressionImpl(expression, IrConstKind.Int, convertedText.toInt(), "Incorrect int: $text") } else { - FirErrorExpressionImpl(session, expression, reason = "Incorrect constant expression: $text") + FirErrorExpressionImpl(expression, reason = "Incorrect constant expression: $text") } KtNodeTypes.FLOAT_CONSTANT -> if (convertedText is Float) { FirConstExpressionImpl( - session, expression, IrConstKind.Float, convertedText, "Incorrect float: $text" + expression, IrConstKind.Float, convertedText, "Incorrect float: $text" ) } else { FirConstExpressionImpl( - session, expression, IrConstKind.Double, convertedText as Double, "Incorrect double: $text" + expression, IrConstKind.Double, convertedText as Double, "Incorrect double: $text" ) } KtNodeTypes.CHARACTER_CONSTANT -> FirConstExpressionImpl( - session, expression, IrConstKind.Char, text.parseCharacter(), "Incorrect character: $text" + expression, IrConstKind.Char, text.parseCharacter(), "Incorrect character: $text" ) KtNodeTypes.BOOLEAN_CONSTANT -> - FirConstExpressionImpl(session, expression, IrConstKind.Boolean, convertedText as Boolean) + FirConstExpressionImpl(expression, IrConstKind.Boolean, convertedText as Boolean) KtNodeTypes.NULL -> - FirConstExpressionImpl(session, expression, IrConstKind.Null, null) + FirConstExpressionImpl(expression, IrConstKind.Null, null) else -> throw AssertionError("Unknown literal type: $type, $text") } @@ -187,59 +187,56 @@ internal fun FirExpression.generateNotNullOrOther( val subjectName = Name.special("<$caseId>") val subjectVariable = generateTemporaryVariable(session, psi, subjectName, this) val subject = FirWhenSubject() - val subjectExpression = FirWhenSubjectExpressionImpl(session, psi, subject) + val subjectExpression = FirWhenSubjectExpressionImpl(psi, subject) return FirWhenExpressionImpl( - session, basePsi, this, subjectVariable + basePsi, this, subjectVariable ).apply { subject.bind(this) branches += FirWhenBranchImpl( - session, psi, - FirOperatorCallImpl(session, psi, FirOperation.EQ).apply { + psi, + FirOperatorCallImpl(psi, FirOperation.EQ).apply { arguments += subjectExpression - arguments += FirConstExpressionImpl(session, psi, IrConstKind.Null, null) + arguments += FirConstExpressionImpl(psi, IrConstKind.Null, null) }, - FirSingleExpressionBlock(session, other) + FirSingleExpressionBlock(other) ) branches += FirWhenBranchImpl( - session, other.psi, FirElseIfTrueCondition(session, psi), + other.psi, FirElseIfTrueCondition(psi), FirSingleExpressionBlock( - session, - FirUncheckedNotNullCastImpl(session, psi, generateResolvedAccessExpression(session, psi, subjectVariable)) + FirUncheckedNotNullCastImpl(psi, generateResolvedAccessExpression(psi, subjectVariable)) ) ) } } internal fun FirExpression.generateLazyLogicalOperation( - session: FirSession, other: FirExpression, isAnd: Boolean, basePsi: KtElement + other: FirExpression, isAnd: Boolean, basePsi: KtElement ): FirWhenExpression { - val terminalExpression = FirConstExpressionImpl(session, psi, IrConstKind.Boolean, !isAnd) - val terminalBlock = FirSingleExpressionBlock(session, terminalExpression) - val otherBlock = FirSingleExpressionBlock(session, other) - return FirWhenExpressionImpl(session, basePsi).apply { + val terminalExpression = FirConstExpressionImpl(psi, IrConstKind.Boolean, !isAnd) + val terminalBlock = FirSingleExpressionBlock(terminalExpression) + val otherBlock = FirSingleExpressionBlock(other) + return FirWhenExpressionImpl(basePsi).apply { branches += FirWhenBranchImpl( - session, psi, this@generateLazyLogicalOperation, + psi, this@generateLazyLogicalOperation, if (isAnd) otherBlock else terminalBlock ) branches += FirWhenBranchImpl( - session, other.psi, FirElseIfTrueCondition(session, psi), + other.psi, FirElseIfTrueCondition(psi), if (isAnd) terminalBlock else otherBlock ) - typeRef = FirImplicitBooleanTypeRef(session, basePsi) + typeRef = FirImplicitBooleanTypeRef(basePsi) } } internal fun KtWhenCondition.toFirWhenCondition( - session: FirSession, subject: FirWhenSubject, convert: KtExpression?.(String) -> FirExpression, toFirOrErrorTypeRef: KtTypeReference?.() -> FirTypeRef ): FirExpression { - val firSubjectExpression = FirWhenSubjectExpressionImpl(session, this, subject) + val firSubjectExpression = FirWhenSubjectExpressionImpl(this, subject) return when (this) { is KtWhenConditionWithExpression -> { FirOperatorCallImpl( - session, expression, FirOperation.EQ ).apply { @@ -249,24 +246,23 @@ internal fun KtWhenCondition.toFirWhenCondition( } is KtWhenConditionInRange -> { 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 -> { FirTypeOperatorCallImpl( - session, typeReference, if (isNegated) FirOperation.NOT_IS else FirOperation.IS, + typeReference, if (isNegated) FirOperation.NOT_IS else FirOperation.IS, typeReference.toFirOrErrorTypeRef() ).apply { arguments += firSubjectExpression } } else -> { - FirErrorExpressionImpl(session, this, "Unsupported when condition: ${this.javaClass}") + FirErrorExpressionImpl(this, "Unsupported when condition: ${this.javaClass}") } } } internal fun Array.toFirWhenCondition( - session: FirSession, basePsi: KtElement, subject: FirWhenSubject, convert: KtExpression?.(String) -> FirExpression, @@ -274,11 +270,11 @@ internal fun Array.toFirWhenCondition( ): FirExpression { var firCondition: FirExpression? = null for (condition in this) { - val firConditionElement = condition.toFirWhenCondition(session, subject, convert, toFirOrErrorTypeRef) + val firConditionElement = condition.toFirWhenCondition(subject, convert, toFirOrErrorTypeRef) firCondition = when (firCondition) { null -> firConditionElement else -> firCondition.generateLazyLogicalOperation( - session, firConditionElement, false, basePsi + firConditionElement, false, basePsi ) } } @@ -286,7 +282,6 @@ internal fun Array.toFirWhenCondition( } internal fun Array.toInterpolatingCall( - session: FirSession, base: KtStringTemplateExpression, convert: KtExpression?.(String) -> FirExpression ): FirExpression { @@ -298,11 +293,11 @@ internal fun Array.toInterpolatingCall( val nextArgument = when (entry) { is KtLiteralStringTemplateEntry -> { sb.append(entry.text) - FirConstExpressionImpl(session, entry, IrConstKind.String, entry.text) + FirConstExpressionImpl(entry, IrConstKind.String, entry.text) } is KtEscapeStringTemplateEntry -> { sb.append(entry.unescapedValue) - FirConstExpressionImpl(session, entry, IrConstKind.String, entry.unescapedValue) + FirConstExpressionImpl(entry, IrConstKind.String, entry.unescapedValue) } is KtStringTemplateEntryWithExpression -> { val innerExpression = entry.expression @@ -312,7 +307,7 @@ internal fun Array.toInterpolatingCall( else -> { hasExpressions = true FirErrorExpressionImpl( - session, entry, "Incorrect template entry: ${entry.text}" + entry, "Incorrect template entry: ${entry.text}" ) } } @@ -323,31 +318,30 @@ internal fun Array.toInterpolatingCall( } else -> { callCreated = true - FirStringConcatenationCallImpl(session, base).apply { + FirStringConcatenationCallImpl(base).apply { arguments += result!! 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( - session: FirSession, argument: FirExpression, inverted: Boolean, base: KtExpression?, operationReference: KtOperationReferenceExpression ): FirFunctionCall { - val containsCall = FirFunctionCallImpl(session, base).apply { - calleeReference = FirSimpleNamedReference(session, operationReference, OperatorNameConventions.CONTAINS) + val containsCall = FirFunctionCallImpl(base).apply { + calleeReference = FirSimpleNamedReference(operationReference, OperatorNameConventions.CONTAINS) explicitReceiver = this@generateContainsOperation arguments += argument } if (!inverted) return containsCall - return FirFunctionCallImpl(session, base).apply { - calleeReference = FirSimpleNamedReference(session, operationReference, OperatorNameConventions.NOT) + return FirFunctionCallImpl(base).apply { + calleeReference = FirSimpleNamedReference(operationReference, OperatorNameConventions.NOT) explicitReceiver = containsCall } } @@ -386,22 +380,22 @@ internal fun generateIncrementOrDecrementBlock( convert: KtExpression.() -> FirExpression ): FirExpression { 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("") val temporaryVariable = generateTemporaryVariable(session, baseExpression, tempName, argument.convert()) statements += temporaryVariable val resultName = Name.special("") - val resultInitializer = FirFunctionCallImpl(session, baseExpression).apply { - this.calleeReference = FirSimpleNamedReference(session, baseExpression.operationReference, callName) - this.explicitReceiver = generateResolvedAccessExpression(session, baseExpression, temporaryVariable) + val resultInitializer = FirFunctionCallImpl(baseExpression).apply { + this.calleeReference = FirSimpleNamedReference(baseExpression.operationReference, callName) + this.explicitReceiver = generateResolvedAccessExpression(baseExpression, temporaryVariable) } val resultVar = generateTemporaryVariable(session, baseExpression, resultName, resultInitializer) val assignment = argument.generateAssignment( session, baseExpression, if (prefix && argument !is KtSimpleNameExpression) - generateResolvedAccessExpression(session, baseExpression, resultVar) + generateResolvedAccessExpression(baseExpression, resultVar) else resultInitializer, FirOperation.ASSIGN, convert @@ -419,26 +413,26 @@ internal fun generateIncrementOrDecrementBlock( if (argument !is KtSimpleNameExpression) { statements += resultVar appendAssignment() - statements += generateResolvedAccessExpression(session, baseExpression, resultVar) + statements += generateResolvedAccessExpression(baseExpression, resultVar) } else { appendAssignment() - statements += generateAccessExpression(session, baseExpression, argument.getReferencedNameAsName()) + statements += generateAccessExpression(baseExpression, argument.getReferencedNameAsName()) } } else { appendAssignment() - statements += generateResolvedAccessExpression(session, baseExpression, temporaryVariable) + statements += generateResolvedAccessExpression(baseExpression, temporaryVariable) } } } -internal fun generateAccessExpression(session: FirSession, psi: PsiElement?, name: Name): FirQualifiedAccessExpression = - FirQualifiedAccessExpressionImpl(session, psi).apply { - calleeReference = FirSimpleNamedReference(session, psi, name) +internal fun generateAccessExpression(psi: PsiElement?, name: Name): FirQualifiedAccessExpression = + FirQualifiedAccessExpressionImpl(psi).apply { + calleeReference = FirSimpleNamedReference(psi, name) } -internal fun generateResolvedAccessExpression(session: FirSession, psi: PsiElement?, variable: FirVariable<*>): FirQualifiedAccessExpression = - FirQualifiedAccessExpressionImpl(session, psi).apply { - calleeReference = FirResolvedCallableReferenceImpl(session, psi, variable.name, variable.symbol) +internal fun generateResolvedAccessExpression(psi: PsiElement?, variable: FirVariable<*>): FirQualifiedAccessExpression = + FirQualifiedAccessExpressionImpl(psi).apply { + calleeReference = FirResolvedCallableReferenceImpl(psi, variable.name, variable.symbol) } internal fun generateDestructuringBlock( @@ -449,7 +443,7 @@ internal fun generateDestructuringBlock( extractAnnotationsTo: KtAnnotated.(FirAbstractAnnotatedElement) -> Unit, toFirOrImplicitTypeRef: KtTypeReference?.() -> FirTypeRef ): FirExpression { - return FirBlockImpl(session, multiDeclaration).apply { + return FirBlockImpl(multiDeclaration).apply { if (tmpVariable) { statements += container } @@ -458,7 +452,7 @@ internal fun generateDestructuringBlock( statements += FirVariableImpl( session, entry, entry.nameAsSafeName, entry.typeReference.toFirOrImplicitTypeRef(), isVar, - FirComponentCallImpl(session, entry, index + 1, generateResolvedAccessExpression(session, entry, container)), + FirComponentCallImpl(entry, index + 1, generateResolvedAccessExpression(entry, container)), FirVariableSymbol(entry.nameAsSafeName) // TODO? ).apply { entry.extractAnnotationsTo(this) @@ -471,7 +465,7 @@ internal fun generateDestructuringBlock( internal fun generateTemporaryVariable( session: FirSession, psi: PsiElement?, name: Name, initializer: FirExpression ): 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) } @@ -480,16 +474,15 @@ internal fun generateTemporaryVariable( ): FirVariable<*> = generateTemporaryVariable(session, psi, Name.special("<$specialName>"), initializer) private fun FirModifiableQualifiedAccess<*>.initializeLValue( - session: FirSession, left: KtExpression?, convertQualified: KtQualifiedExpression.() -> FirQualifiedAccess? ): FirReference { return when (left) { is KtSimpleNameExpression -> { - FirSimpleNamedReference(session, left, left.getReferencedNameAsName()) + FirSimpleNamedReference(left, left.getReferencedNameAsName()) } is KtThisExpression -> { - FirExplicitThisReference(session, left, left.getLabelName()) + FirExplicitThisReference(left, left.getLabelName()) } is KtQualifiedExpression -> { val firMemberAccess = left.convertQualified() @@ -498,14 +491,14 @@ private fun FirModifiableQualifiedAccess<*>.initializeLValue( safe = firMemberAccess.safe firMemberAccess.calleeReference } else { - FirErrorNamedReference(session, left, "Unsupported qualified LValue: ${left.text}") + FirErrorNamedReference(left, "Unsupported qualified LValue: ${left.text}") } } is KtParenthesizedExpression -> { - initializeLValue(session, left.expression, convertQualified) + initializeLValue(left.expression, convertQualified) } 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) { 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) { - FirArraySetCallImpl(session, psi, value, operation).apply { + FirArraySetCallImpl(psi, value, operation).apply { for (indexExpression in indexExpressions) { indexes += indexExpression.convert() } } } else { - return FirFunctionCallImpl(session, psi).apply { - calleeReference = FirSimpleNamedReference(session, psi, OperatorNameConventions.SET) + return FirFunctionCallImpl(psi).apply { + calleeReference = FirSimpleNamedReference(psi, OperatorNameConventions.SET) explicitReceiver = firArrayExpression for (indexExpression in indexExpressions) { arguments += indexExpression.convert() @@ -541,32 +534,32 @@ internal fun KtExpression?.generateAssignment( } if (arrayExpression is KtSimpleNameExpression) { 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("") 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 && this !is KtSimpleNameExpression && this !is KtThisExpression && (this !is KtQualifiedExpression || selectorExpression !is KtSimpleNameExpression) ) { - return FirBlockImpl(session, this).apply { + return FirBlockImpl(this).apply { val name = Name.special("") statements += generateTemporaryVariable( 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 { - lValue = FirSimpleNamedReference(session, this@generateAssignment, name) + statements += FirVariableAssignmentImpl(psi, value, operation).apply { + lValue = FirSimpleNamedReference(this@generateAssignment, name) } } } - return FirVariableAssignmentImpl(session, psi, value, operation).apply { - lValue = initializeLValue(session, this@generateAssignment) { convert() as? FirQualifiedAccess } + return FirVariableAssignmentImpl(psi, value, operation).apply { + lValue = initializeLValue(this@generateAssignment) { convert() as? FirQualifiedAccess } } } @@ -574,37 +567,36 @@ internal fun FirModifiableAccessorsOwner.generateAccessorsByDelegate(session: Fi val variable = this as FirVariable<*> val delegateFieldSymbol = delegateFieldSymbol ?: return val delegate = delegate as? FirWrappedDelegateExpressionImpl ?: return - fun delegateAccess() = FirQualifiedAccessExpressionImpl(session, null).apply { - calleeReference = FirDelegateFieldReferenceImpl(session, null, delegateFieldSymbol) + fun delegateAccess() = FirQualifiedAccessExpressionImpl(null).apply { + calleeReference = FirDelegateFieldReferenceImpl(null, delegateFieldSymbol) } fun thisRef() = - if (member) FirQualifiedAccessExpressionImpl(session, null).apply { - calleeReference = FirExplicitThisReference(session, null, null) + if (member) FirQualifiedAccessExpressionImpl(null).apply { + calleeReference = FirExplicitThisReference(null, null) } - else FirConstExpressionImpl(session, null, IrConstKind.Null, null) + else FirConstExpressionImpl(null, IrConstKind.Null, null) - fun propertyRef() = FirCallableReferenceAccessImpl(session, null).apply { - calleeReference = FirResolvedCallableReferenceImpl(session, null, variable.name, variable.symbol) - typeRef = FirImplicitKPropertyTypeRef(session, null, ConeStarProjection) + fun propertyRef() = FirCallableReferenceAccessImpl(null).apply { + calleeReference = FirResolvedCallableReferenceImpl(null, variable.name, variable.symbol) + 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 - calleeReference = FirSimpleNamedReference(session, null, PROVIDE_DELEGATE) + calleeReference = FirSimpleNamedReference(null, PROVIDE_DELEGATE) arguments += thisRef() arguments += propertyRef() } if (stubMode) return 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( - session, FirReturnExpressionImpl( - session, null, - FirFunctionCallImpl(session, null).apply { + null, + FirFunctionCallImpl(null).apply { explicitReceiver = delegateAccess() - calleeReference = FirSimpleNamedReference(session, null, GET_VALUE) + calleeReference = FirSimpleNamedReference(null, GET_VALUE) arguments += thisRef() arguments += propertyRef() } @@ -615,22 +607,22 @@ internal fun FirModifiableAccessorsOwner.generateAccessorsByDelegate(session: Fi ) } 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( session, null, DELEGATED_SETTER_PARAM, - FirImplicitTypeRefImpl(session, null), + FirImplicitTypeRefImpl(null), defaultValue = null, isCrossinline = false, isNoinline = false, isVararg = false ) valueParameters += parameter body = FirSingleExpressionBlock( - session, FirFunctionCallImpl(session, null).apply { + FirFunctionCallImpl(null).apply { explicitReceiver = delegateAccess() - calleeReference = FirSimpleNamedReference(session, null, SET_VALUE) + calleeReference = FirSimpleNamedReference(null, SET_VALUE) arguments += thisRef() arguments += propertyRef() - arguments += FirQualifiedAccessExpressionImpl(session, null).apply { - calleeReference = FirResolvedCallableReferenceImpl(session, psi, DELEGATED_SETTER_PARAM, parameter.symbol) + arguments += FirQualifiedAccessExpressionImpl(null).apply { + calleeReference = FirResolvedCallableReferenceImpl(psi, DELEGATED_SETTER_PARAM, parameter.symbol) } } ) diff --git a/compiler/fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/DataClassUtils.kt b/compiler/fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/DataClassUtils.kt index 4b977473e0b..2d6fb7eab18 100644 --- a/compiler/fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/DataClassUtils.kt +++ b/compiler/fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/DataClassUtils.kt @@ -45,17 +45,16 @@ internal fun KtClassOrObject.generateComponentFunctions( isInfix = false, isInline = false, isTailRec = false, isExternal = false, isSuspend = false, receiverTypeRef = null, - returnTypeRef = FirImplicitTypeRefImpl(session, ktParameter) + returnTypeRef = FirImplicitTypeRefImpl(ktParameter) ).apply { val componentFunction = this body = FirSingleExpressionBlock( - session, FirReturnExpressionImpl( - session, ktParameter, - FirQualifiedAccessExpressionImpl(session, ktParameter).apply { + ktParameter, + FirQualifiedAccessExpressionImpl(ktParameter).apply { val parameterName = ktParameter.nameAsSafeName calleeReference = FirResolvedCallableReferenceImpl( - session, ktParameter, + ktParameter, parameterName, firProperty.symbol ) } @@ -96,14 +95,14 @@ internal fun KtClassOrObject.generateCopyFunction( valueParameters += FirValueParameterImpl( session, ktParameter, name, ktParameter.typeReference.toFirOrErrorTypeRef(), - FirQualifiedAccessExpressionImpl(session, ktParameter).apply { - calleeReference = FirResolvedCallableReferenceImpl(session, ktParameter, name, firProperty.symbol) + FirQualifiedAccessExpressionImpl(ktParameter).apply { + calleeReference = FirResolvedCallableReferenceImpl(ktParameter, name, firProperty.symbol) }, isCrossinline = false, isNoinline = false, isVararg = false ) } - body = FirEmptyExpressionBlock(session) + body = FirEmptyExpressionBlock() // body = FirSingleExpressionBlock( // session, // FirReturnExpressionImpl( diff --git a/compiler/fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/RawFirBuilder.kt b/compiler/fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/RawFirBuilder.kt index 4b4a0022a03..6b5eb71b837 100644 --- a/compiler/fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/RawFirBuilder.kt +++ b/compiler/fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/RawFirBuilder.kt @@ -35,13 +35,13 @@ import org.jetbrains.kotlin.util.OperatorNameConventions 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 { 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 private fun KtTypeReference?.toFirOrImplicitType(): FirTypeRef = - convertSafe() ?: FirImplicitTypeRefImpl(session, this) + convertSafe() ?: FirImplicitTypeRefImpl(this) private fun KtTypeReference?.toFirOrUnitType(): FirTypeRef = convertSafe() ?: implicitUnitType 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 private fun (() -> KtExpression?).toFirExpression(errorReason: String): FirExpression = - if (stubMode) FirExpressionStub(session, null) + if (stubMode) FirExpressionStub(null) else with(this()) { - convertSafe() ?: FirErrorExpressionImpl(session, this, errorReason) + convertSafe() ?: FirErrorExpressionImpl(this, errorReason) } private fun KtExpression?.toFirExpression(errorReason: String): FirExpression = - if (stubMode) FirExpressionStub(session, null) - else convertSafe() ?: FirErrorExpressionImpl(session, this, errorReason) + if (stubMode) FirExpressionStub(null) + else convertSafe() ?: FirErrorExpressionImpl(this, errorReason) private fun KtExpression.toFirStatement(errorReason: String): FirStatement = - convertSafe() ?: FirErrorExpressionImpl(session, this, errorReason) + convertSafe() ?: FirErrorExpressionImpl(this, errorReason) private fun KtExpression.toFirStatement(): FirStatement = convert() @@ -108,7 +108,7 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) { return when (this) { is KtSecondaryConstructor -> toFirConstructor( delegatedSuperType, - delegatedSelfType ?: FirErrorTypeRefImpl(this@RawFirBuilder.session, this, "Constructor in object"), + delegatedSelfType ?: FirErrorTypeRefImpl(this, "Constructor in object"), owner, hasPrimaryConstructor ) @@ -121,20 +121,13 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) { is KtBlockExpression -> accept(this@Visitor, Unit) as FirBlock null -> - FirEmptyExpressionBlock(session) + FirEmptyExpressionBlock() else -> - FirSingleExpressionBlock( - session, - convert() - ) + FirSingleExpressionBlock(convert()) } private fun FirExpression.toReturn(basePsi: PsiElement? = psi, labelName: String? = null): FirReturnExpression { - return FirReturnExpressionImpl( - this@RawFirBuilder.session, - basePsi, - this - ).apply { + return FirReturnExpressionImpl(basePsi, this).apply { target = FirFunctionTarget(labelName) val lastFunction = firFunctions.lastOrNull() if (labelName == null) { @@ -172,22 +165,16 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) { hasBlockBody() -> if (!stubMode) { bodyBlockExpression?.accept(this@Visitor, Unit) as? FirBlock } else { - FirSingleExpressionBlock( - session, - FirExpressionStub(session, this).toReturn() - ) + FirSingleExpressionBlock(FirExpressionStub(this).toReturn()) } else -> { val result = { bodyExpression }.toFirExpression("Function has no body (but should)") - FirSingleExpressionBlock( - session, - result.toReturn() - ) + FirSingleExpressionBlock(result.toReturn()) } } 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 expression = this.getArgumentExpression() val firExpression = when (expression) { @@ -201,8 +188,8 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) { } val isSpread = getSpreadElement() != null return when { - name != null -> FirNamedArgumentExpressionImpl(session, expression, name, isSpread, firExpression) - isSpread -> FirSpreadArgumentExpressionImpl(session, expression, firExpression) + name != null -> FirNamedArgumentExpressionImpl(expression, name, isSpread, firExpression) + isSpread -> FirSpreadArgumentExpressionImpl(expression, firExpression) else -> firExpression } } @@ -280,9 +267,9 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) { receiverTypeRef = null, returnTypeRef = type, isVar = isMutable, - initializer = FirQualifiedAccessExpressionImpl(session, this).apply { + initializer = FirQualifiedAccessExpressionImpl(this).apply { calleeReference = FirPropertyFromParameterCallableReference( - this@RawFirBuilder.session, this@toFirProperty, nameAsSafeName, firParameter.symbol + this@toFirProperty, nameAsSafeName, firParameter.symbol ) }, delegate = null @@ -319,7 +306,7 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) { for (argument in this.valueArguments) { val argumentExpression = argument.toFirExpression() container.arguments += when (argument) { - is KtLambdaArgument -> FirLambdaArgumentExpressionImpl(session, argument, argumentExpression) + is KtLambdaArgument -> FirLambdaArgumentExpressionImpl(argument, argumentExpression) else -> argumentExpression } } @@ -343,7 +330,7 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) { is KtDelegatedSuperTypeEntry -> { val type = superTypeListEntry.typeReference.toFirOrErrorType() container.superTypeRefs += FirDelegatedTypeRefImpl( - session, type, + type, { superTypeListEntry.delegateExpression }.toFirExpression("Should have delegate") ) } @@ -384,7 +371,6 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) { ): FirConstructor { val constructorCallee = superTypeCallEntry?.calleeExpression val firDelegatedCall = FirDelegatedConstructorCallImpl( - session, constructorCallee ?: (this ?: owner), delegatedSuperTypeRef, isThis = false @@ -427,7 +413,6 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) { } for (importDirective in file.importDirectives) { firFile.imports += FirImportImpl( - session, importDirective, importDirective.importedFqName, importDirective.isAllUnder, @@ -448,7 +433,6 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) { } } return FirResolvedTypeRefImpl( - session, this, ConeClassTypeImpl( firClass.symbol.toLookupTag(), @@ -460,7 +444,7 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) { private fun FirTypeParameterImpl.addDefaultBoundIfNecessary() { 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 { val objectDeclaration = expression.objectDeclaration - return FirAnonymousObjectImpl(session, expression).apply { + return FirAnonymousObjectImpl(expression).apply { objectDeclaration.extractAnnotationsTo(this) objectDeclaration.extractSuperTypeListEntriesTo(this, null) 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 { val literal = expression.functionLiteral - val returnType = FirImplicitTypeRefImpl(session, literal) - val receiverType = FirImplicitTypeRefImpl(session, literal) + val returnType = FirImplicitTypeRefImpl(literal) + val receiverType = FirImplicitTypeRefImpl(literal) return FirAnonymousFunctionImpl(session, literal, returnType, receiverType).apply { firFunctions += this var destructuringBlock: FirExpression? = null @@ -675,7 +659,7 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) { valueParameters += if (multiDeclaration != null) { val multiParameter = FirValueParameterImpl( this@RawFirBuilder.session, valueParameter, Name.special(""), - FirImplicitTypeRefImpl(this@RawFirBuilder.session, multiDeclaration), + FirImplicitTypeRefImpl(multiDeclaration), defaultValue = null, isCrossinline = false, isNoinline = false, isVararg = false ) destructuringBlock = generateDestructuringBlock( @@ -687,16 +671,16 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) { ) { toFirOrImplicitType() } multiParameter } else { - valueParameter.toFirValueParameter(FirImplicitTypeRefImpl(this@RawFirBuilder.session, psi)) + valueParameter.toFirValueParameter(FirImplicitTypeRefImpl(psi)) } } 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") body = if (bodyExpression is FirBlockImpl) { if (bodyExpression.statements.isEmpty()) { - bodyExpression.statements.add(FirUnitExpression(this@RawFirBuilder.session, expression)) + bodyExpression.statements.add(FirUnitExpression(expression)) } if (destructuringBlock is FirBlock) { for ((index, statement) in destructuringBlock.statements.withIndex()) { @@ -705,7 +689,7 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) { } bodyExpression } else { - FirSingleExpressionBlock(this@RawFirBuilder.session, bodyExpression.toReturn()) + FirSingleExpressionBlock(bodyExpression.toReturn()) } firFunctions.removeLast() @@ -752,10 +736,9 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) { val isThis = isCallToThis || (isImplicit && hasPrimaryConstructor) val delegatedType = when { isThis -> delegatedSelfTypeRef - else -> delegatedSuperTypeRef ?: FirErrorTypeRefImpl(session, this, "No super type") + else -> delegatedSuperTypeRef ?: FirErrorTypeRefImpl(this, "No super type") } return FirDelegatedConstructorCallImpl( - session, this, delegatedType, isThis @@ -770,7 +753,7 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) { return FirAnonymousInitializerImpl( session, 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, delegate = delegateExpression?.let { FirWrappedDelegateExpressionImpl( - session, it, + it, it.toFirExpression("Incorrect delegate expression") ) } @@ -818,7 +801,7 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) { initializer, if (property.hasDelegate()) { FirWrappedDelegateExpressionImpl( - session, if (stubMode) null else delegateExpression, + if (stubMode) null else delegateExpression, { delegateExpression }.toFirExpression("Should have delegate") ) } else null @@ -841,12 +824,12 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) { if (this is KtNullableType) this.innerType.unwrapNullable() else this val firType = when (val unwrappedElement = typeElement.unwrapNullable()) { - is KtDynamicType -> FirDynamicTypeRefImpl(session, typeReference, isNullable) + is KtDynamicType -> FirDynamicTypeRefImpl(typeReference, isNullable) is KtUserType -> { var referenceExpression = unwrappedElement.referenceExpression if (referenceExpression != null) { val userType = FirUserTypeRefImpl( - session, typeReference, isNullable + typeReference, isNullable ) var qualifier: KtUserType? = unwrappedElement do { @@ -864,12 +847,11 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) { userType } else { - FirErrorTypeRefImpl(session, typeReference, "Incomplete user type") + FirErrorTypeRefImpl(typeReference, "Incomplete user type") } } is KtFunctionType -> { val functionType = FirFunctionTypeRefImpl( - session, typeReference, isNullable, unwrappedElement.receiverTypeReference.convertSafe(), @@ -881,7 +863,7 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) { } functionType } - null -> FirErrorTypeRefImpl(session, typeReference, "Unwrapped type is null") + null -> FirErrorTypeRefImpl(typeReference, "Unwrapped type is null") 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 { val firAnnotationCall = FirAnnotationCallImpl( - session, annotationEntry, annotationEntry.useSiteTarget?.getAnnotationUseSiteTarget(), annotationEntry.typeReference.toFirOrErrorType() @@ -931,7 +912,7 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) { override fun visitTypeProjection(typeProjection: KtTypeProjection, data: Unit): FirElement { val projectionKind = typeProjection.projectionKind if (projectionKind == KtProjectionKind.STAR) { - return FirStarProjectionImpl(session, typeProjection) + return FirStarProjectionImpl(typeProjection) } if (projectionKind == KtProjectionKind.NONE && typeProjection.text == "_") { return FirTypePlaceholderProjection @@ -939,7 +920,6 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) { val typeReference = typeProjection.typeReference val firType = typeReference.toFirOrErrorType() return FirTypeProjectionWithVarianceImpl( - session, typeProjection, when (projectionKind) { KtProjectionKind.IN -> Variance.IN_VARIANCE @@ -955,7 +935,7 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) { parameter.toFirValueParameter() override fun visitBlockExpression(expression: KtBlockExpression, data: Unit): FirElement { - return FirBlockImpl(session, expression).apply { + return FirBlockImpl(expression).apply { for (statement in expression.statements) { val firStatement = statement.toFirStatement("Statement expected: ${statement.text}") 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 { - return generateAccessExpression(session, expression, expression.getReferencedNameAsName()) + return generateAccessExpression(expression, expression.getReferencedNameAsName()) } override fun visitConstantExpression(expression: KtConstantExpression, data: Unit): FirElement = - generateConstantExpressionByLiteral(session, expression) + generateConstantExpressionByLiteral(expression) 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 { val result = expression.returnedExpression?.toFirExpression("Incorrect return expression") - ?: FirUnitExpression(session, expression) + ?: FirUnitExpression(expression) return result.toReturn(expression, expression.getTargetLabel()?.getReferencedName()) } override fun visitTryExpression(expression: KtTryExpression, data: Unit): FirElement { val tryBlock = expression.tryBlock.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) { val parameter = clause.catchParameter?.toFirValueParameter() ?: continue 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 { - return FirWhenExpressionImpl( - session, - expression - ).apply { + return FirWhenExpressionImpl(expression).apply { val condition = expression.condition val firCondition = condition.toFirExpression("If statement should have condition") val trueBranch = expression.then.toFirBlock() - branches += FirWhenBranchImpl(this@RawFirBuilder.session, condition, firCondition, trueBranch) + branches += FirWhenBranchImpl(condition, firCondition, trueBranch) val elseBranch = expression.`else`.toFirBlock() 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 subject = FirWhenSubject() return FirWhenExpressionImpl( - session, expression, subjectExpression, subjectVariable @@ -1042,22 +1018,19 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) { branches += if (!entry.isElse) { if (hasSubject) { val firCondition = entry.conditions.toFirWhenCondition( - this@RawFirBuilder.session, entry, subject, { toFirExpression(it) }, { toFirOrErrorType() } ) - FirWhenBranchImpl(this@RawFirBuilder.session, entry, firCondition, branch) + FirWhenBranchImpl(entry, firCondition, branch) } else { val condition = entry.conditions.first() as? KtWhenConditionWithExpression val firCondition = condition?.expression.toFirExpression("No expression in condition with expression") - FirWhenBranchImpl(this@RawFirBuilder.session, entry, firCondition, branch) + FirWhenBranchImpl(entry, firCondition, branch) } } else { - FirWhenBranchImpl( - this@RawFirBuilder.session, entry, FirElseIfTrueCondition(this@RawFirBuilder.session, null), branch - ) + FirWhenBranchImpl(entry, FirElseIfTrueCondition(null), branch) } } } @@ -1075,52 +1048,52 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) { override fun visitDoWhileExpression(expression: KtDoWhileExpression, data: Unit): FirElement { 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() } } override fun visitWhileExpression(expression: KtWhileExpression, data: Unit): FirElement { 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() } } override fun visitForExpression(expression: KtForExpression, data: Unit?): FirElement { val rangeExpression = expression.loopRange.toFirExpression("No range in for loop") val parameter = expression.loopParameter - return FirBlockImpl(session, expression).apply { + return FirBlockImpl(expression).apply { val rangeVal = generateTemporaryVariable(this@RawFirBuilder.session, expression.loopRange, Name.special(""), rangeExpression) statements += rangeVal val iteratorVal = generateTemporaryVariable( this@RawFirBuilder.session, expression.loopRange, Name.special(""), - FirFunctionCallImpl(this@RawFirBuilder.session, expression).apply { - calleeReference = FirSimpleNamedReference(this@RawFirBuilder.session, expression, Name.identifier("iterator")) - explicitReceiver = generateResolvedAccessExpression(this@RawFirBuilder.session, expression.loopRange, rangeVal) + FirFunctionCallImpl(expression).apply { + calleeReference = FirSimpleNamedReference(expression, Name.identifier("iterator")) + explicitReceiver = generateResolvedAccessExpression(expression.loopRange, rangeVal) } ) statements += iteratorVal statements += FirWhileLoopImpl( - this@RawFirBuilder.session, expression, - FirFunctionCallImpl(this@RawFirBuilder.session, expression).apply { - calleeReference = FirSimpleNamedReference(this@RawFirBuilder.session, expression, Name.identifier("hasNext")) - explicitReceiver = generateResolvedAccessExpression(this@RawFirBuilder.session, expression, iteratorVal) + expression, + FirFunctionCallImpl(expression).apply { + calleeReference = FirSimpleNamedReference(expression, Name.identifier("hasNext")) + explicitReceiver = generateResolvedAccessExpression(expression, iteratorVal) } ).configure { // NB: just body.toFirBlock() isn't acceptable here because we need to add some statements val block = when (val body = expression.body) { is KtBlockExpression -> body.accept(this@Visitor, Unit) as FirBlockImpl - null -> FirBlockImpl(this@RawFirBuilder.session, body) - else -> FirBlockImpl(this@RawFirBuilder.session, body).apply { statements += body.toFirStatement() } + null -> FirBlockImpl(body) + else -> FirBlockImpl(body).apply { statements += body.toFirStatement() } } if (parameter != null) { val multiDeclaration = parameter.destructuringDeclaration val firLoopParameter = generateTemporaryVariable( this@RawFirBuilder.session, expression.loopParameter, if (multiDeclaration != null) Name.special("") else parameter.nameAsSafeName, - FirFunctionCallImpl(this@RawFirBuilder.session, expression).apply { - calleeReference = FirSimpleNamedReference(this@RawFirBuilder.session, expression, Name.identifier("next")) - explicitReceiver = generateResolvedAccessExpression(this@RawFirBuilder.session, expression, iteratorVal) + FirFunctionCallImpl(expression).apply { + calleeReference = FirSimpleNamedReference(expression, Name.identifier("next")) + explicitReceiver = generateResolvedAccessExpression(expression, iteratorVal) } ) if (multiDeclaration != null) { @@ -1153,7 +1126,7 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) { if (lastLoop != null) { target.bind(lastLoop) } 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 { for (firLoop in firLoops.asReversed()) { @@ -1162,25 +1135,25 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) { 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 } 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 { - return FirContinueExpressionImpl(session, expression).bindLabel(expression) + return FirContinueExpressionImpl(expression).bindLabel(expression) } private fun KtUnaryExpression.bangBangToWhen(): FirWhenExpression { return baseExpression.toFirExpression("No operand").generateNotNullOrOther( session, FirThrowExpressionImpl( - session, this, FirFunctionCallImpl(session, this).apply { - calleeReference = FirSimpleNamedReference(this@RawFirBuilder.session, this@bangBangToWhen, KNPE) + this, FirFunctionCallImpl(this).apply { + calleeReference = FirSimpleNamedReference(this@bangBangToWhen, KNPE) } ), "bangbang", this ) @@ -1194,19 +1167,17 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) { ELVIS -> return leftArgument.generateNotNullOrOther(session, rightArgument, "elvis", expression) ANDAND, OROR -> - return leftArgument.generateLazyLogicalOperation(session, rightArgument, operationToken == ANDAND, expression) + return leftArgument.generateLazyLogicalOperation(rightArgument, operationToken == ANDAND, expression) in OperatorConventions.IN_OPERATIONS -> return rightArgument.generateContainsOperation( - session, leftArgument, operationToken == NOT_IN, expression, expression.operationReference + leftArgument, operationToken == NOT_IN, expression, expression.operationReference ) } val conventionCallName = operationToken.toBinaryName() return if (conventionCallName != null || operationToken == IDENTIFIER) { - FirFunctionCallImpl( - session, expression - ).apply { + FirFunctionCallImpl(expression).apply { calleeReference = FirSimpleNamedReference( - this@RawFirBuilder.session, expression.operationReference, + expression.operationReference, conventionCallName ?: expression.operationReference.getReferencedNameAsName() ) explicitReceiver = leftArgument @@ -1219,7 +1190,7 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) { toFirExpression("Incorrect expression in assignment: ${expression.text}") } } else { - FirOperatorCallImpl(session, expression, firOperation).apply { + FirOperatorCallImpl(expression, firOperation).apply { arguments += leftArgument arguments += rightArgument } @@ -1230,7 +1201,7 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) { override fun visitBinaryWithTypeRHSExpression(expression: KtBinaryExpressionWithTypeRHS, data: Unit): FirElement { val operation = expression.operationReference.getReferencedNameElementType().toFirOperation() return FirTypeOperatorCallImpl( - session, expression, operation, expression.right.toFirOrErrorType() + expression, operation, expression.right.toFirOrErrorType() ).apply { 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 { 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() ).apply { arguments += expression.leftHandSide.toFirExpression("No left operand") @@ -1260,19 +1231,15 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) { prefix = expression is KtPrefixExpression ) { toFirExpression("Incorrect expression inside inc/dec") } } - FirFunctionCallImpl( - session, expression - ).apply { + FirFunctionCallImpl(expression).apply { calleeReference = FirSimpleNamedReference( - this@RawFirBuilder.session, expression.operationReference, conventionCallName + expression.operationReference, conventionCallName ) explicitReceiver = argument.toFirExpression("No operand") } } else { val firOperation = operationToken.toFirOperation() - FirOperatorCallImpl( - session, expression, firOperation - ).apply { + FirOperatorCallImpl(expression, firOperation).apply { 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 { val calleeExpression = expression.calleeExpression - return FirFunctionCallImpl(session, expression).apply { + return FirFunctionCallImpl(expression).apply { val calleeReference = when (calleeExpression) { is KtSimpleNameExpression -> FirSimpleNamedReference( - this@RawFirBuilder.session, calleeExpression, calleeExpression.getReferencedNameAsName() + calleeExpression, calleeExpression.getReferencedNameAsName() ) null -> FirErrorNamedReference( - this@RawFirBuilder.session, calleeExpression, "Call has no callee" + calleeExpression, "Call has no callee" ) else -> { arguments += calleeExpression.toFirExpression("Incorrect invoke receiver") 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 { val arrayExpression = expression.arrayExpression - return FirFunctionCallImpl(session, expression).apply { - calleeReference = FirSimpleNamedReference(this@RawFirBuilder.session, expression, OperatorNameConventions.GET) + return FirFunctionCallImpl(expression).apply { + calleeReference = FirSimpleNamedReference(expression, OperatorNameConventions.GET) explicitReceiver = arrayExpression.toFirExpression("No array expression") for (indexExpression in expression.indexExpressions) { 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 { 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") if (firSelector is FirModifiableQualifiedAccess<*>) { 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 { val labelName = expression.getLabelName() - return FirQualifiedAccessExpressionImpl(session, expression).apply { - calleeReference = FirExplicitThisReference(this@RawFirBuilder.session, expression, labelName) + return FirQualifiedAccessExpressionImpl(expression).apply { + calleeReference = FirExplicitThisReference(expression, labelName) } } override fun visitSuperExpression(expression: KtSuperExpression, data: Unit): FirElement { val superType = expression.superTypeQualifier - return FirQualifiedAccessExpressionImpl(session, expression).apply { - calleeReference = FirExplicitSuperReference(this@RawFirBuilder.session, expression, superType.toFirOrImplicitType()) + return FirQualifiedAccessExpressionImpl(expression).apply { + calleeReference = FirExplicitSuperReference(expression, superType.toFirOrImplicitType()) } } 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() @@ -1353,9 +1320,9 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) { val labelName = expression.getLabelName() val size = firLabels.size 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) { firLabels.removeLast() 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 { val rawResult = expression.baseExpression?.accept(this, data) val result = rawResult as? FirAbstractAnnotatedElement - ?: FirErrorExpressionImpl(session, expression, "Strange annotated expression: ${rawResult?.render()}") + ?: FirErrorExpressionImpl(expression, "Strange annotated expression: ${rawResult?.render()}") expression.extractAnnotationsTo(result) return result } 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 { @@ -1392,22 +1359,22 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) { } 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") } } override fun visitCallableReferenceExpression(expression: KtCallableReferenceExpression, data: Unit): FirElement { - return FirCallableReferenceAccessImpl(session, expression).apply { + return FirCallableReferenceAccessImpl(expression).apply { calleeReference = FirSimpleNamedReference( - this@RawFirBuilder.session, expression.callableReference, expression.callableReference.getReferencedNameAsName() + expression.callableReference, expression.callableReference.getReferencedNameAsName() ) explicitReceiver = expression.receiverExpression?.toFirExpression("Incorrect receiver expression") } } override fun visitCollectionLiteralExpression(expression: KtCollectionLiteralExpression, data: Unit): FirElement { - return FirArrayOfCallImpl(session, expression).apply { + return FirArrayOfCallImpl(expression).apply { for (innerExpression in expression.getInnerExpressions()) { 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 { - return FirExpressionStub(session, expression) + return FirExpressionStub(expression) } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/CopyUtils.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/CopyUtils.kt index 93f79889cf9..787d1814315 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/CopyUtils.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/CopyUtils.kt @@ -29,13 +29,10 @@ fun FirFunctionCall.copy( explicitReceiver: FirExpression? = this.explicitReceiver, psi: PsiElement? = this.psi, safe: Boolean = this.safe, - session: FirSession = this.session, typeArguments: List = this.typeArguments, resultType: FirTypeRef = this.typeRef ): FirFunctionCall { - return FirFunctionCallImpl( - session, psi, safe - ).apply { + return FirFunctionCallImpl(psi, safe).apply { this.annotations.addAll(annotations) this.arguments.addAll(arguments) this.calleeReference = calleeReference @@ -69,9 +66,7 @@ fun FirAnonymousFunction.copy( fun FirTypeRef.resolvedTypeFromPrototype( type: ConeKotlinType ): FirResolvedTypeRef { - return FirResolvedTypeRefImpl( - session, psi, type, annotations - ) + return FirResolvedTypeRefImpl(psi, type, annotations) } fun FirTypeParameter.copy( diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirCallResolver.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirCallResolver.kt index 4bb358b76de..dcf3a5c82a0 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirCallResolver.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirCallResolver.kt @@ -188,7 +188,7 @@ class FirCallResolver( else -> null } if (referencedSymbol is ConeClassLikeSymbol) { - return FirResolvedQualifierImpl(session, nameReference.psi, referencedSymbol.classId).apply { + return FirResolvedQualifierImpl(nameReference.psi, referencedSymbol.classId).apply { resultType = typeForQualifier(this) } } @@ -209,15 +209,14 @@ class FirCallResolver( applicability: CandidateApplicability ): FirNamedReference { val name = namedReference.name - val firSession = namedReference.session val psi = namedReference.psi return when { candidates.isEmpty() -> FirErrorNamedReference( - firSession, psi, "Unresolved name: $name" + psi, "Unresolved name: $name" ) applicability < CandidateApplicability.SYNTHETIC_RESOLVED -> { FirErrorNamedReference( - firSession, psi, + psi, "Inapplicable($applicability): ${candidates.map { describeSymbol(it.symbol) }}", namedReference.name ) @@ -226,15 +225,15 @@ class FirCallResolver( val candidate = candidates.single() val coneSymbol = candidate.symbol when { - coneSymbol is FirBackingFieldSymbol -> FirBackingFieldReferenceImpl(firSession, psi, coneSymbol) + coneSymbol is FirBackingFieldSymbol -> FirBackingFieldReferenceImpl(psi, coneSymbol) coneSymbol is FirVariableSymbol && (coneSymbol !is FirPropertySymbol || coneSymbol.firUnsafe().typeParameters.isEmpty()) -> - FirResolvedCallableReferenceImpl(firSession, psi, name, coneSymbol) - else -> FirNamedReferenceWithCandidate(firSession, psi, name, candidate) + FirResolvedCallableReferenceImpl(psi, name, coneSymbol) + else -> FirNamedReferenceWithCandidate(psi, name, candidate) } } else -> FirErrorNamedReference( - firSession, psi, "Ambiguity: $name, ${candidates.map { describeSymbol(it.symbol) }}", + psi, "Ambiguity: $name, ${candidates.map { describeSymbol(it.symbol) }}", namedReference.name ) } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirQualifiedNameResolver.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirQualifiedNameResolver.kt index 63d51f1d5e2..d0ce8df3804 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirQualifiedNameResolver.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirQualifiedNameResolver.kt @@ -58,12 +58,10 @@ class FirQualifiedNameResolver(components: BodyResolveComponents) : BodyResolveC if (resolved != null) { qualifierPartsToDrop = qualifierParts.size - 1 return FirResolvedQualifierImpl( - session, null /* TODO */, resolved.packageFqName, resolved.relativeClassFqName - ) - .apply { resultType = typeForQualifier(this) } + ).apply { resultType = typeForQualifier(this) } } return null diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/deserialization/AbstractAnnotationDeserializer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/deserialization/AbstractAnnotationDeserializer.kt index 39c1f677354..9f777396db8 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/deserialization/AbstractAnnotationDeserializer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/deserialization/AbstractAnnotationDeserializer.kt @@ -83,19 +83,19 @@ abstract class AbstractAnnotationDeserializer( val parameter = parameterByName[name] ?: return@mapNotNull null val value = resolveValue(parameter.returnTypeRef, it.value, nameResolver) ?: return@mapNotNull null FirNamedArgumentExpressionImpl( - session, null, name, false, value + null, name, false, value ) } } } return FirAnnotationCallImpl( - session, null, null, + null, null, symbol?.let { 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 { this.arguments += arguments } @@ -117,27 +117,25 @@ abstract class AbstractAnnotationDeserializer( BOOLEAN -> const(IrConstKind.Boolean, (value.intValue != 0L)) STRING -> const(IrConstKind.String, nameResolver.getString(value.stringValue)) ANNOTATION -> deserializeAnnotation(value.annotation, nameResolver) - CLASS -> FirGetClassCallImpl(session, null).apply { + CLASS -> FirGetClassCallImpl(null).apply { val classId = nameResolver.getClassId(value.classId) val lookupTag = ConeClassLikeLookupTagImpl(classId) val referencedType = lookupTag.constructType(emptyArray(), isNullable = false) arguments += FirClassReferenceExpressionImpl( - this@AbstractAnnotationDeserializer.session, null, - FirResolvedTypeRefImpl( - this@AbstractAnnotationDeserializer.session, null, referencedType - ) + null, + FirResolvedTypeRefImpl(null, referencedType) ) } - ENUM -> FirFunctionCallImpl(session, null).apply { + ENUM -> FirFunctionCallImpl(null).apply { val classId = nameResolver.getClassId(value.classId) val entryName = nameResolver.getName(value.enumValueId) val entryClassId = classId.createNestedClassId(entryName) val entryLookupTag = ConeClassLikeLookupTagImpl(entryClassId) val entrySymbol = entryLookupTag.toSymbol(this@AbstractAnnotationDeserializer.session) this.calleeReference = entrySymbol?.let { - FirResolvedCallableReferenceImpl(this@AbstractAnnotationDeserializer.session, null, entryName, it) + FirResolvedCallableReferenceImpl(null, entryName, it) } ?: FirErrorNamedReference( - this@AbstractAnnotationDeserializer.session, null, + null, errorReason = "Strange deserialized enum value: $classId.$entryName" ) } @@ -150,5 +148,5 @@ abstract class AbstractAnnotationDeserializer( return result } - private fun const(kind: IrConstKind, value: T) = FirConstExpressionImpl(session, null, kind, value) + private fun const(kind: IrConstKind, value: T) = FirConstExpressionImpl(null, kind, value) } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/deserialization/ClassDeserialization.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/deserialization/ClassDeserialization.kt index 48532587924..f024041a99e 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/deserialization/ClassDeserialization.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/deserialization/ClassDeserialization.kt @@ -68,7 +68,7 @@ fun deserializeClassToSymbol( superTypesDeserialized.mapNotNullTo(superTypeRefs) { if (it == null) return@mapNotNullTo null - FirResolvedTypeRefImpl(session, null, it) + FirResolvedTypeRefImpl(null, it) } addDeclarations(classProto.functionList.map(classDeserializer::loadFunction)) @@ -95,7 +95,6 @@ fun deserializeClassToSymbol( val symbol = FirClassSymbol(enumEntryId) FirEnumEntryImpl(session, null, symbol, enumEntryId.shortClassName).apply { superTypeRefs += FirResolvedTypeRefImpl( - session, null, ConeClassTypeImpl(ConeClassLikeLookupTagImpl(classId), emptyArray(), false), emptyList() diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/deserialization/FirMemberDeserializer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/deserialization/FirMemberDeserializer.kt index a5978a14e49..aa6b90b0e40 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/deserialization/FirMemberDeserializer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/deserialization/FirMemberDeserializer.kt @@ -136,7 +136,6 @@ class FirMemberDeserializer(private val c: FirDeserializationContext) { Flags.IS_EXPECT_CLASS.get(flags), false, FirResolvedTypeRefImpl( - c.session, null, local.typeDeserializer.type(proto.underlyingType(c.typeTable)), emptyList() /* TODO */ @@ -239,7 +238,6 @@ class FirMemberDeserializer(private val c: FirDeserializationContext) { } val delegatedSelfType = FirResolvedTypeRefImpl( - c.session, null, ConeClassTypeImpl( klass.symbol.toLookupTag(), @@ -280,7 +278,7 @@ class FirMemberDeserializer(private val c: FirDeserializationContext) { private fun defaultValue(flags: Int): FirExpression? { if (Flags.DECLARES_DEFAULT_VALUE.get(flags)) { - return FirExpressionStub(c.session, null) + return FirExpressionStub(null) } return null } @@ -306,7 +304,7 @@ class FirMemberDeserializer(private val c: FirDeserializationContext) { private fun ProtoBuf.Type.toTypeRef(context: FirDeserializationContext): FirTypeRef { val coneType = context.typeDeserializer.type(this) return FirResolvedTypeRefImpl( - context.session, null, coneType, + null, coneType, context.annotationDeserializer.loadTypeAnnotations(this, context.nameResolver) ) } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/deserialization/FirTypeDeserializer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/deserialization/FirTypeDeserializer.kt index 5beedd483ad..8153d3fd16e 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/deserialization/FirTypeDeserializer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/deserialization/FirTypeDeserializer.kt @@ -96,7 +96,7 @@ class FirTypeDeserializer( val declaration = symbol.fir as FirTypeParameterImpl declaration.apply { proto.upperBoundList.mapTo(bounds) { - FirResolvedTypeRefImpl(session, null, type(it), emptyList()) + FirResolvedTypeRefImpl(null, type(it), emptyList()) } } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ResolveUtils.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ResolveUtils.kt index fbbc4670b27..86e9db570fd 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ResolveUtils.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ResolveUtils.kt @@ -169,7 +169,7 @@ fun FirFunction.constructFunctionalTypeRef(session: FirSession): FirResolvedType val functionalTypeId = StandardClassIds.byName("Function${receiverAndParameterTypes.size - 1}") 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 { @@ -214,7 +214,7 @@ fun BodyResolveComponents.typeFromCallee(access: T): Fi return when (val newCallee = access.calleeReference) { is FirErrorNamedReference -> - FirErrorTypeRefImpl(session, access.psi, newCallee.errorReason) + FirErrorTypeRefImpl(access.psi, newCallee.errorReason) is FirNamedReferenceWithCandidate -> { typeFromSymbol(newCallee.candidateSymbol, makeNullable) } @@ -225,7 +225,7 @@ fun BodyResolveComponents.typeFromCallee(access: T): Fi val labelName = newCallee.labelName val types = if (labelName == null) labels.values() else labels[Name.identifier(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") } @@ -237,7 +237,6 @@ private fun BodyResolveComponents.typeFromSymbol(symbol: ConeSymbol, makeNullabl val returnType = returnTypeCalculator.tryCalculateReturnType(symbol.fir) if (makeNullable) { returnType.withReplacedConeType( - session, returnType.coneTypeUnsafe().withNullability(ConeNullability.NULLABLE) ) } else { @@ -249,13 +248,12 @@ private fun BodyResolveComponents.typeFromSymbol(symbol: ConeSymbol, makeNullabl // TODO: unhack if (fir is FirEnumEntry) { (fir.superTypeRefs.firstOrNull() as? FirResolvedTypeRef) ?: FirErrorTypeRefImpl( - session, null, "no enum item supertype" ) } else FirResolvedTypeRefImpl( - session, null, symbol.constructType(emptyArray(), isNullable = false), + null, symbol.constructType(emptyArray(), isNullable = false), annotations = emptyList() ) } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/CandidateCollector.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/CandidateCollector.kt index dec06ea4d4d..105a650297d 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/CandidateCollector.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/CandidateCollector.kt @@ -82,9 +82,8 @@ class InvokeReceiverCandidateCollector( val session = components.session val boundInvokeCallInfo = CallInfo( invokeCallInfo.callKind, - FirQualifiedAccessExpressionImpl(session, null, false).apply { + FirQualifiedAccessExpressionImpl(null, false).apply { calleeReference = FirNamedReferenceWithCandidate( - session, null, (candidate.symbol as ConeCallableSymbol).callableId.callableName, candidate diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/FirNamedReferenceWithCandidate.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/FirNamedReferenceWithCandidate.kt index b8764f2b10d..8b20be5faee 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/FirNamedReferenceWithCandidate.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/FirNamedReferenceWithCandidate.kt @@ -6,13 +6,15 @@ package org.jetbrains.kotlin.fir.resolve.calls import com.intellij.psi.PsiElement -import org.jetbrains.kotlin.fir.* import org.jetbrains.kotlin.fir.references.FirSimpleNamedReference import org.jetbrains.kotlin.fir.symbols.ConeSymbol import org.jetbrains.kotlin.name.Name -class FirNamedReferenceWithCandidate(session: FirSession, psi: PsiElement?, name: Name, val candidate: Candidate) : - FirSimpleNamedReference(session, psi, name) { +class FirNamedReferenceWithCandidate( + psi: PsiElement?, + name: Name, + val candidate: Candidate +) : FirSimpleNamedReference(psi, name) { override val candidateSymbol: ConeSymbol get() = candidate.symbol } \ No newline at end of file diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/TowerLevels.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/TowerLevels.kt index 753d0808c95..d5009942829 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/TowerLevels.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/TowerLevels.kt @@ -207,8 +207,7 @@ class QualifiedReceiverTowerLevel(session: FirSession) : SessionBasedTowerLevel( val scope = FirExplicitSimpleImportingScope( listOf( FirResolvedImportImpl( - session, - FirImportImpl(session, null, FqName.topLevel(name), false, null), + FirImportImpl(null, FqName.topLevel(name), false, null), qualifiedReceiver.packageFqName, qualifiedReceiver.relativeClassFqName ) diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/impl/FirLibrarySymbolProviderImpl.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/impl/FirLibrarySymbolProviderImpl.kt index 75b9cdbf8d7..0e69e195116 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/impl/FirLibrarySymbolProviderImpl.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/impl/FirLibrarySymbolProviderImpl.kt @@ -182,7 +182,7 @@ class FirLibrarySymbolProviderImpl(val session: FirSession) : FirSymbolProvider( ).apply klass@{ typeParameters.addAll((1..arity).map { FirTypeParameterImpl( - session, + this@FirLibrarySymbolProviderImpl.session, null, FirTypeParameterSymbol(), Name.identifier("P$it"), @@ -192,7 +192,7 @@ class FirLibrarySymbolProviderImpl(val session: FirSession) : FirSymbolProvider( }) typeParameters.add( FirTypeParameterImpl( - session, + this@FirLibrarySymbolProviderImpl.session, null, FirTypeParameterSymbol(), Name.identifier("R"), @@ -203,7 +203,7 @@ class FirLibrarySymbolProviderImpl(val session: FirSession) : FirSymbolProvider( val name = OperatorNameConventions.INVOKE addDeclaration( FirMemberFunctionImpl( - session, + this@FirLibrarySymbolProviderImpl.session, null, FirNamedFunctionSymbol(CallableId(packageFqName, relativeClassName, name)), name, @@ -220,7 +220,6 @@ class FirLibrarySymbolProviderImpl(val session: FirSession) : FirSymbolProvider( isSuspend = false, receiverTypeRef = null, returnTypeRef = FirResolvedTypeRefImpl( - session, null, ConeTypeParameterTypeImpl( typeParameters.last().symbol.toLookupTag(), @@ -230,11 +229,10 @@ class FirLibrarySymbolProviderImpl(val session: FirSession) : FirSymbolProvider( ).apply { valueParameters += this@klass.typeParameters.dropLast(1).map { typeParameter -> FirValueParameterImpl( - session, + this@FirLibrarySymbolProviderImpl.session, null, Name.identifier(typeParameter.name.asString().toLowerCase()), FirResolvedTypeRefImpl( - session, null, ConeTypeParameterTypeImpl(typeParameter.symbol.toLookupTag(), false) ), @@ -246,7 +244,7 @@ class FirLibrarySymbolProviderImpl(val session: FirSession) : FirSymbolProvider( } } ) - replaceSupertypes(listOf(FirImplicitAnyTypeRef(session, null))) + replaceSupertypes(listOf(FirImplicitAnyTypeRef(null))) } } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/FirCallCompleter.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/FirCallCompleter.kt index bdadf4bcfa9..f3412486905 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/FirCallCompleter.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/FirCallCompleter.kt @@ -94,7 +94,7 @@ class FirCallCompleter( session, null, Name.identifier("it"), - FirResolvedTypeRefImpl(session, null, parameters.single(), emptyList()), + FirResolvedTypeRefImpl(null, parameters.single(), emptyList()), defaultValue = null, isCrossinline = false, isNoinline = false, diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirBodyResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirBodyResolveTransformer.kt index da101f5e061..23671ea223f 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirBodyResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirBodyResolveTransformer.kt @@ -48,7 +48,7 @@ open class FirBodyResolveTransformer( ) : FirTransformer(), BodyResolveComponents { final override val returnTypeCalculator: ReturnTypeCalculator = ReturnTypeCalculatorWithJump(session, scopeSession) override val labels: SetMultimap = LinkedHashMultimap.create() - override val noExpectedType = FirImplicitTypeRefImpl(session, null) + override val noExpectedType = FirImplicitTypeRefImpl(null) override val symbolProvider = session.service() val scopes = mutableListOf() @@ -157,7 +157,7 @@ open class FirBodyResolveTransformer( val notNullCast = super.transformUncheckedNotNullCast(uncheckedNotNullCast, data).single as FirUncheckedNotNullCast val resultType = notNullCast.expression.resultType notNullCast.resultType = - resultType.withReplacedConeType(session, resultType.coneTypeUnsafe().withNullability(ConeNullability.NOT_NULL)) + resultType.withReplacedConeType(resultType.coneTypeUnsafe().withNullability(ConeNullability.NOT_NULL)) return notNullCast.compose() } @@ -167,7 +167,6 @@ open class FirBodyResolveTransformer( when ((resolved as FirTypeOperatorCall).operation) { FirOperation.IS, FirOperation.NOT_IS -> { resolved.resultType = FirResolvedTypeRefImpl( - session, null, StandardClassIds.Boolean(symbolProvider).constructType(emptyArray(), isNullable = false), emptyList() @@ -179,7 +178,6 @@ open class FirBodyResolveTransformer( FirOperation.SAFE_AS -> { resolved.resultType = resolved.conversionTypeRef.withReplacedConeType( - session, resolved.conversionTypeRef.coneTypeUnsafe().withNullability(ConeNullability.NULLABLE) ) } @@ -198,7 +196,7 @@ open class FirBodyResolveTransformer( val labelName = callee.labelName val types = if (labelName == null) labels.values() else labels[Name.identifier(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() } is FirSuperReference -> { @@ -207,7 +205,7 @@ open class FirBodyResolveTransformer( } else { val superTypeRef = implicitReceiverStack.filterIsInstance().lastOrNull() ?.boundSymbol?.fir?.superTypeRefs?.firstOrNull() - ?: FirErrorTypeRefImpl(session, qualifiedAccessExpression.psi, "No super type") + ?: FirErrorTypeRefImpl(qualifiedAccessExpression.psi, "No super type") qualifiedAccessExpression.resultType = superTypeRef callee.replaceSuperTypeRef(superTypeRef) } @@ -277,7 +275,7 @@ open class FirBodyResolveTransformer( session, null, Name.identifier("it"), - FirResolvedTypeRefImpl(session, null, singleParameterType, emptyList()), + FirResolvedTypeRefImpl(null, singleParameterType, emptyList()), defaultValue = null, isCrossinline = false, isNoinline = false, @@ -311,7 +309,7 @@ open class FirBodyResolveTransformer( returnTypeRef = (af.returnTypeRef as? FirResolvedTypeRef) ?: resolvedLambdaAtom?.returnType?.let { af.returnTypeRef.resolvedTypeFromPrototype(it) } ?: 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.compose() @@ -361,9 +359,9 @@ open class FirBodyResolveTransformer( val type = commonSuperType((listOf(tryExpression.tryBlock) + tryExpression.catches.map { it.block }).map { val expression = it.statements.lastOrNull() as? FirExpression 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 { - FirImplicitUnitTypeRef(session, null) + FirImplicitUnitTypeRef(null) } }) if (type != null) tryExpression.resultType = type @@ -414,9 +412,9 @@ open class FirBodyResolveTransformer( else -> null } block.resultType = if (resultExpression == null) { - FirImplicitUnitTypeRef(session, block.psi) + FirImplicitUnitTypeRef(block.psi) } 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() @@ -429,7 +427,7 @@ open class FirBodyResolveTransformer( commonSuperType(types.map { it.coneTypeUnsafe() }) } } as ConeKotlinType - return FirResolvedTypeRefImpl(session, null, commonSuperType, emptyList()) + return FirResolvedTypeRefImpl(null, commonSuperType, emptyList()) } override fun transformWhenExpression(whenExpression: FirWhenExpression, data: Any?): CompositeTransformResult { @@ -438,9 +436,9 @@ open class FirBodyResolveTransformer( val type = commonSuperType(whenExpression.branches.map { val expression = it.result.statements.lastOrNull() as? FirExpression 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 { - FirImplicitUnitTypeRef(session, null) + FirImplicitUnitTypeRef(null) } }) if (type != null) whenExpression.resultType = type @@ -482,7 +480,7 @@ open class FirBodyResolveTransformer( val type = ConeClassTypeImpl(symbol.toLookupTag(), emptyArray(), isNullable = kind == IrConstKind.Null) - constExpression.resultType = FirResolvedTypeRefImpl(session, null, type, emptyList()) + constExpression.resultType = FirResolvedTypeRefImpl(null, type, emptyList()) } else { constExpression.resultType = expectedType } @@ -576,7 +574,6 @@ open class FirBodyResolveTransformer( this, when (val resultType = initializer.resultType) { is FirImplicitTypeRef -> FirErrorTypeRefImpl( - session, null, "No result type for initializer" ) @@ -589,7 +586,6 @@ open class FirBodyResolveTransformer( this, when (val resultType = variable.getter?.returnTypeRef) { is FirImplicitTypeRef -> FirErrorTypeRefImpl( - session, null, "No result type for getter" ) @@ -599,7 +595,7 @@ open class FirBodyResolveTransformer( } else -> { 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 { 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 } return (expression.transformChildren(this, data) as FirStatement).compose() @@ -705,7 +701,6 @@ open class FirBodyResolveTransformer( transformedGetClassCall.resultType = FirResolvedTypeRefImpl( - session, null, kClassSymbol.constructType(arrayOf(typeOfExpression), false), emptyList() diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirCallCompletionResultsWriterTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirCallCompletionResultsWriterTransformer.kt index e6e460f025f..3f06ad264c7 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirCallCompletionResultsWriterTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirCallCompletionResultsWriterTransformer.kt @@ -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.FirTypeProjectionWithVarianceImpl 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.types.Variance @@ -47,13 +46,12 @@ class FirCallCompletionResultsWriterTransformer( val initialType = calleeReference.candidate.substitutor.substituteOrNull(typeRef.type) val finalType = finalSubstitutor.substituteOrNull(initialType) - val resultType = typeRef.withReplacedConeType(session, finalType) + val resultType = typeRef.withReplacedConeType(finalType) qualifiedAccessExpression.replaceTypeRef(resultType) return qualifiedAccessExpression.transformCalleeReference( StoreCalleeReference, FirResolvedCallableReferenceImpl( - calleeReference.session, calleeReference.psi, calleeReference.name, calleeReference.candidateSymbol @@ -70,7 +68,6 @@ class FirCallCompletionResultsWriterTransformer( return variableAssignment.transformCalleeReference( StoreCalleeReference, FirResolvedCallableReferenceImpl( - calleeReference.session, calleeReference.psi, calleeReference.name, calleeReference.candidateSymbol @@ -92,18 +89,16 @@ class FirCallCompletionResultsWriterTransformer( is FirTypeProjectionWithVariance -> { val typeRef = argument.typeRef as FirResolvedTypeRef FirTypeProjectionWithVarianceImpl( - session, argument.psi, argument.variance, - typeRef.withReplacedConeType(session, type) + typeRef.withReplacedConeType(type) ) } else -> { FirTypeProjectionWithVarianceImpl( - session, argument?.psi, 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 finalType = finalSubstitutor.substituteOrNull(initialType) - val resultType = typeRef.withReplacedConeType(session, finalType) + val resultType = typeRef.withReplacedConeType(finalType) return functionCall.copy( resultType = resultType, typeArguments = newTypeParameters, calleeReference = FirResolvedCallableReferenceImpl( - calleeReference.session, calleeReference.psi, calleeReference.name, calleeReference.candidateSymbol @@ -137,7 +131,7 @@ class FirCallCompletionResultsWriterTransformer( if (initialType != null) { val finalType = finalSubstitutor.substituteOrNull(initialType) - val resultType = anonymousFunction.returnTypeRef.withReplacedConeType(session, finalType) + val resultType = anonymousFunction.returnTypeRef.withReplacedConeType(finalType) anonymousFunction.transformReturnTypeRef(StoreType, resultType) diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirImportResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirImportResolveTransformer.kt index d27d5d0816f..f3479c9ad04 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirImportResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirImportResolveTransformer.kt @@ -50,7 +50,7 @@ class FirImportResolveTransformer() : FirAbstractTreeTransformer() { private fun transformImportForFqName(fqName: FqName, delegate: FirImport): CompositeTransformResult { val (packageFqName, relativeClassFqName) = resolveToPackageOrClass(symbolProvider, fqName) ?: return delegate.compose() - return FirResolvedImportImpl(session, delegate, packageFqName, relativeClassFqName).compose() + return FirResolvedImportImpl(delegate, packageFqName, relativeClassFqName).compose() } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSpecificTypeResolverTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSpecificTypeResolverTransformer.kt index 13911ebdf70..46e469e66dc 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSpecificTypeResolverTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSpecificTypeResolverTransformer.kt @@ -33,7 +33,6 @@ class FirSpecificTypeResolverTransformer( functionTypeRef.transformChildren(this, data) return FirResolvedFunctionTypeRefImpl( functionTypeRef.psi, - session, functionTypeRef.isMarkedNullable, functionTypeRef.annotations as MutableList, functionTypeRef.receiverTypeRef, @@ -45,7 +44,6 @@ class FirSpecificTypeResolverTransformer( private fun transformType(typeRef: FirTypeRef, resolvedType: ConeKotlinType): CompositeTransformResult { return FirResolvedTypeRefImpl( - session, typeRef.psi, resolvedType, typeRef.annotations diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSupertypeResolverTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSupertypeResolverTransformer.kt index 86fae893fa4..90cce176bc0 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSupertypeResolverTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSupertypeResolverTransformer.kt @@ -144,7 +144,7 @@ class FirSupertypeResolverTransformer : FirAbstractTreeTransformer() { if (superTypeClassId.outerClasses().any(currentlyComputing::contains)) { resultingTypeRefs.add( - FirErrorTypeRefImpl(session, superTypeRef.psi, "Recursion detected: ${superTypeRef.render()}") + FirErrorTypeRefImpl(superTypeRef.psi, "Recursion detected: ${superTypeRef.render()}") ) continue diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirTypeResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirTypeResolveTransformer.kt index 4cfcd7a87bd..537e2059ad0 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirTypeResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirTypeResolveTransformer.kt @@ -104,7 +104,6 @@ open class FirTypeResolveTransformer : FirAbstractTreeTransformerWithSuperTypes( valueParameter.transformReturnTypeRef( StoreType, valueParameter.returnTypeRef.withReplacedConeType( - session, returnType.createArrayOf(session) ) ) diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/ReturnTypeCalculator.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/ReturnTypeCalculator.kt index c72157b6b6e..571a4dd2dfe 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/ReturnTypeCalculator.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/ReturnTypeCalculator.kt @@ -31,7 +31,7 @@ class ReturnTypeCalculatorWithJump(val session: FirSession, val scopeSession: Sc if (declaration.returnTypeRef is FirComputingImplicitTypeRef) { declaration.transformReturnTypeRef( TransformImplicitType, - FirErrorTypeRefImpl(session, null, "cycle") + FirErrorTypeRefImpl(null, "cycle") ) return declaration.returnTypeRef as FirResolvedTypeRef } @@ -45,7 +45,6 @@ class ReturnTypeCalculatorWithJump(val session: FirSession, val scopeSession: Sc declaration.transformReturnTypeRef( TransformImplicitType, FirErrorTypeRefImpl( - session, null, "Unsupported: implicit VP type" ) @@ -69,7 +68,6 @@ class ReturnTypeCalculatorWithJump(val session: FirSession, val scopeSession: Sc }.mapTo(mutableListOf()) { provider.getFirClassifierByFqName(it) } if (file == null || outerClasses.any { it == null }) return FirErrorTypeRefImpl( - session, null, "I don't know what todo" ) diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirClassSubstitutionScope.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirClassSubstitutionScope.kt index 3bf6d694998..ea4d8f8ef35 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirClassSubstitutionScope.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirClassSubstitutionScope.kt @@ -92,8 +92,8 @@ class FirClassSubstitutionScope( FirMemberFunctionImpl( session, psi, symbol, name, - baseFunction.receiverTypeRef?.withReplacedConeType(session, newReceiverType), - baseFunction.returnTypeRef.withReplacedConeType(session, newReturnType) + baseFunction.receiverTypeRef?.withReplacedConeType(newReceiverType), + baseFunction.returnTypeRef.withReplacedConeType(newReturnType) ).apply { status = baseFunction.status as FirDeclarationStatusImpl valueParameters += baseFunction.valueParameters.zip( @@ -102,7 +102,7 @@ class FirClassSubstitutionScope( with(valueParameter) { FirValueParameterImpl( session, psi, - name, this.returnTypeRef.withReplacedConeType(session, newType), + name, this.returnTypeRef.withReplacedConeType(newType), defaultValue, isCrossinline, isNoinline, isVararg, 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) if (newType == null) return this - return FirResolvedTypeRefImpl( - session, psi, newType, - annotations = annotations - ) + return FirResolvedTypeRefImpl(psi, newType, annotations = annotations) } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirDefaultSimpleImportingScope.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirDefaultSimpleImportingScope.kt index ac2f10d4ca9..f9feab78751 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirDefaultSimpleImportingScope.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirDefaultSimpleImportingScope.kt @@ -21,7 +21,7 @@ class FirDefaultSimpleImportingScope(session: FirSession) : FirAbstractSimpleImp session.moduleInfo?.analyzerServices?.getDefaultImports(LanguageVersionSettingsImpl.DEFAULT, true) ?.filter { !it.isAllUnder } ?.map { - FirImportImpl(session, null, it.fqName, isAllUnder = false, aliasName = null) + FirImportImpl(null, it.fqName, isAllUnder = false, aliasName = null) .resolve(importResolveTransformer) }?.groupBy { it.importedName!! } ?: emptyMap() } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirDefaultStarImportingScope.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirDefaultStarImportingScope.kt index 93515fd0395..cd2ffb89efb 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirDefaultStarImportingScope.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirDefaultStarImportingScope.kt @@ -18,8 +18,7 @@ class FirDefaultStarImportingScope(session: FirSession, lookupInFir: Boolean = f ?.filter { it.isAllUnder } ?.map { FirResolvedImportImpl( - session, - FirImportImpl(session, null, it.fqName, isAllUnder = true, aliasName = null), + FirImportImpl(null, it.fqName, isAllUnder = true, aliasName = null), it.fqName, null ) diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirAbstractElement.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirAbstractElement.kt index 00a491302bd..30966d9f142 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirAbstractElement.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirAbstractElement.kt @@ -10,6 +10,5 @@ import com.intellij.psi.PsiElement abstract class FirPureAbstractElement : FirElement abstract class FirAbstractElement( - final override val session: FirSession, final override val psi: PsiElement? ) : FirPureAbstractElement() \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirElement.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirElement.kt index e90ea044a1d..3f6d7cd19e9 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirElement.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirElement.kt @@ -14,9 +14,6 @@ import org.jetbrains.kotlin.fir.visitors.FirVisitorVoid interface FirElement { val psi: PsiElement? - @Deprecated("It's generally better to obtain use-site session from external source") - val session: FirSession - fun accept(visitor: FirVisitor, data: D): R = visitor.visitElement(this, data) diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirAnonymousFunction.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirAnonymousFunction.kt index 6af35fc3869..9d472c277a6 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirAnonymousFunction.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirAnonymousFunction.kt @@ -14,9 +14,9 @@ import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.fir.visitors.FirVisitor abstract class FirAnonymousFunction( - session: FirSession, + final override val session: FirSession, psi: PsiElement? -) : @VisitedSupertype FirFunction, FirUnknownTypeExpression(session, psi), FirTypedDeclaration, FirLabeledElement { +) : @VisitedSupertype FirFunction, FirUnknownTypeExpression(psi), FirTypedDeclaration, FirLabeledElement { abstract val receiverTypeRef: FirTypeRef? override fun accept(visitor: FirVisitor, data: D): R = diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirAnonymousObject.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirAnonymousObject.kt index b2f32735b4e..d1c6ab77648 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirAnonymousObject.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirAnonymousObject.kt @@ -7,16 +7,11 @@ package org.jetbrains.kotlin.fir.declarations import com.intellij.psi.PsiElement import org.jetbrains.kotlin.descriptors.ClassKind -import org.jetbrains.kotlin.fir.FirSession 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.visitors.FirVisitor -abstract class FirAnonymousObject( - session: FirSession, - psi: PsiElement? -) : @VisitedSupertype FirClass, FirUnknownTypeExpression(session, psi) { +abstract class FirAnonymousObject(psi: PsiElement?) : @VisitedSupertype FirClass, FirUnknownTypeExpression(psi) { override val classKind: ClassKind get() = ClassKind.OBJECT diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirDeclaration.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirDeclaration.kt index c937eba26d5..a785d4b386d 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirDeclaration.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirDeclaration.kt @@ -7,11 +7,14 @@ package org.jetbrains.kotlin.fir.declarations import org.jetbrains.kotlin.fir.BaseTransformedType import org.jetbrains.kotlin.fir.FirElement +import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.visitors.FirVisitor @BaseTransformedType interface FirDeclaration : FirElement { + val session: FirSession + override fun accept(visitor: FirVisitor, data: D): R = visitor.visitDeclaration(this, data) } \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirEnumEntry.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirEnumEntry.kt index e9c0a4a8e0c..53002b284e1 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirEnumEntry.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirEnumEntry.kt @@ -14,9 +14,9 @@ import org.jetbrains.kotlin.fir.visitors.FirVisitor @BaseTransformedType abstract class FirEnumEntry( - session: FirSession, + final override val session: FirSession, psi: PsiElement? -) : @VisitedSupertype FirRegularClass, FirCall(session, psi) { +) : @VisitedSupertype FirRegularClass, FirCall(psi) { override fun accept(visitor: FirVisitor, data: D): R = visitor.visitEnumEntry(this, data) diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirAbstractAnnotatedDeclaration.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirAbstractAnnotatedDeclaration.kt index b049a0c9064..9fb99df861e 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirAbstractAnnotatedDeclaration.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirAbstractAnnotatedDeclaration.kt @@ -11,6 +11,6 @@ import org.jetbrains.kotlin.fir.declarations.FirDeclaration import org.jetbrains.kotlin.fir.expressions.impl.FirAbstractAnnotatedElement abstract class FirAbstractAnnotatedDeclaration( - session: FirSession, + final override val session: FirSession, psi: PsiElement? -) : FirAbstractAnnotatedElement(session, psi), FirDeclaration \ No newline at end of file +) : FirAbstractAnnotatedElement(psi), FirDeclaration \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirAbstractMemberDeclaration.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirAbstractMemberDeclaration.kt index ca772bf450b..66cbe63a936 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirAbstractMemberDeclaration.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirAbstractMemberDeclaration.kt @@ -32,7 +32,6 @@ abstract class FirAbstractMemberDeclaration( isActual: Boolean ) : this(session, psi, name) { this.status = FirDeclarationStatusImpl( - session, visibility, modality ).apply { diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirAnonymousInitializerImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirAnonymousInitializerImpl.kt index 56feb57bf41..58ef1721d14 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirAnonymousInitializerImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirAnonymousInitializerImpl.kt @@ -15,10 +15,10 @@ import org.jetbrains.kotlin.fir.transformSingle import org.jetbrains.kotlin.fir.visitors.FirTransformer class FirAnonymousInitializerImpl( - session: FirSession, + override val session: FirSession, psi: PsiElement?, override var body: FirBlock? -) : FirAnonymousInitializer, FirAbstractElement(session, psi) { +) : FirAnonymousInitializer, FirAbstractElement(psi) { override fun transformChildren(transformer: FirTransformer, data: D): FirElement { body = body?.transformSingle(transformer, data) return this diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirAnonymousObjectImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirAnonymousObjectImpl.kt index bf201c7d4d0..cc8dc7adf6c 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirAnonymousObjectImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirAnonymousObjectImpl.kt @@ -7,7 +7,6 @@ package org.jetbrains.kotlin.fir.declarations.impl import com.intellij.psi.PsiElement 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.FirDeclaration 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.FirVisitor -class FirAnonymousObjectImpl( - session: FirSession, - psi: PsiElement? -) : FirAnonymousObject(session, psi), FirModifiableClass { +class FirAnonymousObjectImpl(psi: PsiElement?) : FirAnonymousObject(psi), FirModifiableClass { override val superTypeRefs = mutableListOf() override val declarations = mutableListOf() diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirClassImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirClassImpl.kt index ecc26b2c9c9..6162bb9d75a 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirClassImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirClassImpl.kt @@ -10,7 +10,6 @@ import org.jetbrains.kotlin.descriptors.ClassKind import org.jetbrains.kotlin.descriptors.Modality import org.jetbrains.kotlin.descriptors.Visibility 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.FirRegularClass import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirDeclarationStatusImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirDeclarationStatusImpl.kt index 20b1155754f..a062f128833 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirDeclarationStatusImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirDeclarationStatusImpl.kt @@ -8,15 +8,13 @@ package org.jetbrains.kotlin.fir.declarations.impl import org.jetbrains.kotlin.descriptors.Modality import org.jetbrains.kotlin.descriptors.Visibility 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.impl.FirDeclarationStatusImpl.Modifier.* open class FirDeclarationStatusImpl( - session: FirSession, override val visibility: Visibility, override val modality: Modality? -) : FirAbstractElement(session, null), FirDeclarationStatus { +) : FirAbstractElement(null), FirDeclarationStatus { protected var flags: Int = 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 { - return FirResolvedDeclarationStatusImpl(session, visibility, modality, flags) + return FirResolvedDeclarationStatusImpl(visibility, modality, flags) } } \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirDefaultPropertyAccessor.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirDefaultPropertyAccessor.kt index b64c4832fc5..4d2bc972965 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirDefaultPropertyAccessor.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirDefaultPropertyAccessor.kt @@ -14,7 +14,6 @@ import org.jetbrains.kotlin.fir.declarations.FirValueParameter import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirBlock 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.transformInplace import org.jetbrains.kotlin.fir.transformSingle @@ -25,14 +24,12 @@ import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name abstract class FirDefaultPropertyAccessor( - session: FirSession, + final override val session: FirSession, psi: PsiElement?, final override val isGetter: Boolean, visibility: Visibility -) : FirAbstractElement(session, psi), FirPropertyAccessor { - override var status = FirDeclarationStatusImpl( - session, visibility, Modality.FINAL - ) +) : FirAbstractElement(psi), FirPropertyAccessor { + override var status = FirDeclarationStatusImpl(visibility, Modality.FINAL) final override val body: FirBlock? = null @@ -81,7 +78,7 @@ class FirDefaultPropertySetter( ) ) - override var returnTypeRef: FirTypeRef = FirImplicitUnitTypeRef(session, psi) + override var returnTypeRef: FirTypeRef = FirImplicitUnitTypeRef(psi) override fun transformChildren(transformer: FirTransformer, data: D): FirElement { valueParameters.transformInplace(transformer, data) diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirEnumEntryImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirEnumEntryImpl.kt index 7e737496fb0..0091c0696be 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirEnumEntryImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirEnumEntryImpl.kt @@ -32,7 +32,7 @@ class FirEnumEntryImpl( symbol.bind(this) } - override var status = FirDeclarationStatusImpl(session, Visibilities.UNKNOWN, Modality.FINAL) + override var status = FirDeclarationStatusImpl(Visibilities.UNKNOWN, Modality.FINAL) override val classKind: ClassKind get() = ClassKind.ENUM_ENTRY @@ -46,7 +46,7 @@ class FirEnumEntryImpl( override val companionObject: FirRegularClass? get() = null - override var typeRef: FirTypeRef = FirImplicitEnumTypeRef(session, null) + override var typeRef: FirTypeRef = FirImplicitEnumTypeRef(null) override val arguments = mutableListOf() diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirErrorFunction.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirErrorFunction.kt index 9192f5c3cb4..26e0698d378 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirErrorFunction.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirErrorFunction.kt @@ -16,10 +16,10 @@ import org.jetbrains.kotlin.fir.expressions.FirBlock import org.jetbrains.kotlin.fir.visitors.FirVisitor class FirErrorFunction( - session: FirSession, + override val session: FirSession, psi: PsiElement?, override val reason: String -) : FirAbstractElement(session, psi), FirErrorDeclaration, FirFunction { +) : FirAbstractElement(psi), FirErrorDeclaration, FirFunction { override val annotations: List get() = emptyList() diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirErrorLoop.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirErrorLoop.kt index eed13096b46..0b6567445ff 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirErrorLoop.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirErrorLoop.kt @@ -7,22 +7,20 @@ package org.jetbrains.kotlin.fir.declarations.impl import com.intellij.psi.PsiElement import org.jetbrains.kotlin.fir.FirAbstractElement -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.expressions.* import org.jetbrains.kotlin.fir.expressions.impl.FirEmptyExpressionBlock import org.jetbrains.kotlin.fir.expressions.impl.FirErrorExpressionImpl import org.jetbrains.kotlin.fir.visitors.FirVisitor class FirErrorLoop( - session: FirSession, psi: PsiElement?, override val reason: String -) : FirAbstractElement(session, psi), FirErrorStatement, FirLoop { +) : FirAbstractElement(psi), FirErrorStatement, FirLoop { override val annotations: List = 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 accept(visitor: FirVisitor, data: D): R { return super.accept(visitor, data) diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirImportImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirImportImpl.kt index 281956f6c20..f2e1a5f5b21 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirImportImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirImportImpl.kt @@ -7,15 +7,13 @@ package org.jetbrains.kotlin.fir.declarations.impl import com.intellij.psi.PsiElement import org.jetbrains.kotlin.fir.FirAbstractElement -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.declarations.FirImport import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name class FirImportImpl( - session: FirSession, psi: PsiElement?, override val importedFqName: FqName?, override val isAllUnder: Boolean, override val aliasName: Name? -) : FirImport, FirAbstractElement(session, psi) \ No newline at end of file +) : FirImport, FirAbstractElement(psi) \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirPropertyAccessorImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirPropertyAccessorImpl.kt index 2ab2af7e8a5..c6d66de2b11 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirPropertyAccessorImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirPropertyAccessorImpl.kt @@ -22,9 +22,7 @@ class FirPropertyAccessorImpl( visibility: Visibility, override var returnTypeRef: FirTypeRef ) : FirAbstractFunction(session, psi), FirPropertyAccessor { - override var status = FirDeclarationStatusImpl( - session, visibility, Modality.FINAL - ) + override var status = FirDeclarationStatusImpl(visibility, Modality.FINAL) override fun transformChildren(transformer: FirTransformer, data: D): FirElement { returnTypeRef = returnTypeRef.transformSingle(transformer, data) diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirResolvedDeclarationStatusImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirResolvedDeclarationStatusImpl.kt index 51a37780555..2e571655b72 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirResolvedDeclarationStatusImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirResolvedDeclarationStatusImpl.kt @@ -5,24 +5,20 @@ package org.jetbrains.kotlin.fir.declarations.impl -import com.intellij.psi.PsiElement import org.jetbrains.kotlin.descriptors.Modality import org.jetbrains.kotlin.descriptors.Visibility -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.declarations.FirResolvedDeclarationStatus class FirResolvedDeclarationStatusImpl( - session: FirSession, visibility: Visibility, modality: Modality -) : FirDeclarationStatusImpl(session, visibility, modality), FirResolvedDeclarationStatus { +) : FirDeclarationStatusImpl(visibility, modality), FirResolvedDeclarationStatus { internal constructor( - session: FirSession, visibility: Visibility, modality: Modality, flags: Int - ) : this(session, visibility, modality) { + ) : this(visibility, modality) { this.flags = flags } diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirResolvedImportImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirResolvedImportImpl.kt index eea062299c8..556b40cf9f6 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirResolvedImportImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirResolvedImportImpl.kt @@ -6,18 +6,16 @@ package org.jetbrains.kotlin.fir.declarations.impl 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.FirResolvedImport import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name class FirResolvedImportImpl( - session: FirSession, val delegate: FirImport, override val packageFqName: FqName, override val relativeClassName: FqName? -) : FirAbstractElement(session, delegate.psi), FirResolvedImport, FirImport { +) : FirAbstractElement(delegate.psi), FirResolvedImport, FirImport { override val aliasName: Name? get() = delegate.aliasName diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirAnnotationCall.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirAnnotationCall.kt index 461ad7a3eb6..8a30acb6921 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirAnnotationCall.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirAnnotationCall.kt @@ -16,10 +16,7 @@ import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.fir.visitors.FirVisitor import org.jetbrains.kotlin.name.FqName -abstract class FirAnnotationCall( - session: FirSession, - psi: PsiElement? -) : FirCallWithArgumentList(session, psi) { +abstract class FirAnnotationCall(psi: PsiElement?) : FirCallWithArgumentList(psi) { abstract val annotationTypeRef: FirTypeRef // May be should be not-null (with correct default target) diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirArrayOfCall.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirArrayOfCall.kt index a14c8d6a30f..b1bd6c9e031 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirArrayOfCall.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirArrayOfCall.kt @@ -6,14 +6,10 @@ package org.jetbrains.kotlin.fir.expressions import com.intellij.psi.PsiElement -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.expressions.impl.FirUnknownTypeCallWithArgumentList import org.jetbrains.kotlin.fir.visitors.FirVisitor -abstract class FirArrayOfCall( - session: FirSession, - psi: PsiElement? -) : FirUnknownTypeCallWithArgumentList(session, psi) { +abstract class FirArrayOfCall(psi: PsiElement?) : FirUnknownTypeCallWithArgumentList(psi) { override fun accept(visitor: FirVisitor, data: D): R = visitor.visitArrayOfCall(this, data) } \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirArraySetCall.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirArraySetCall.kt index bb02635a6cd..f18e84fa004 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirArraySetCall.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirArraySetCall.kt @@ -6,14 +6,12 @@ package org.jetbrains.kotlin.fir.expressions import com.intellij.psi.PsiElement -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.VisitedSupertype import org.jetbrains.kotlin.fir.visitors.FirVisitor abstract class FirArraySetCall( - session: FirSession, psi: PsiElement? -) : @VisitedSupertype FirCall(session, psi), FirAssignment { +) : @VisitedSupertype FirCall(psi), FirAssignment { // NB: arguments of this thing are indexes AND rvalue abstract val indexes: List diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirBlock.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirBlock.kt index 5e0b49d97f1..c7e10fea222 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirBlock.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirBlock.kt @@ -6,14 +6,10 @@ package org.jetbrains.kotlin.fir.expressions import com.intellij.psi.PsiElement -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.expressions.impl.FirUnknownTypeExpression import org.jetbrains.kotlin.fir.visitors.FirVisitor -abstract class FirBlock( - session: FirSession, - psi: PsiElement? -) : FirUnknownTypeExpression(session, psi) { +abstract class FirBlock(psi: PsiElement?) : FirUnknownTypeExpression(psi) { abstract val statements: List override fun accept(visitor: FirVisitor, data: D): R = diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirBreakExpression.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirBreakExpression.kt index 63ad1d8a5b1..c88aca7e1e2 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirBreakExpression.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirBreakExpression.kt @@ -6,14 +6,10 @@ package org.jetbrains.kotlin.fir.expressions import com.intellij.psi.PsiElement -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.expressions.impl.FirLoopJump import org.jetbrains.kotlin.fir.visitors.FirVisitor -abstract class FirBreakExpression( - session: FirSession, - psi: PsiElement? -) : FirLoopJump(session, psi) { +abstract class FirBreakExpression(psi: PsiElement?) : FirLoopJump(psi) { override fun accept(visitor: FirVisitor, data: D): R = visitor.visitBreakExpression(this, data) } \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirCall.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirCall.kt index 7ec0581640a..5e0605bf669 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirCall.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirCall.kt @@ -7,15 +7,11 @@ package org.jetbrains.kotlin.fir.expressions import com.intellij.psi.PsiElement 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.FirVisitor @BaseTransformedType -abstract class FirCall( - session: FirSession, - psi: PsiElement? -) : FirExpression(session, psi) { +abstract class FirCall(psi: PsiElement?) : FirExpression(psi) { abstract val arguments: List override fun accept(visitor: FirVisitor, data: D): R = diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirCallableReferenceAccess.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirCallableReferenceAccess.kt index 10902df7dcd..77ade55bb0c 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirCallableReferenceAccess.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirCallableReferenceAccess.kt @@ -6,13 +6,9 @@ package org.jetbrains.kotlin.fir.expressions import com.intellij.psi.PsiElement -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.visitors.FirVisitor -abstract class FirCallableReferenceAccess( - session: FirSession, - psi: PsiElement? -) : FirQualifiedAccessExpression(session, psi) { +abstract class FirCallableReferenceAccess(psi: PsiElement?) : FirQualifiedAccessExpression(psi) { override fun accept(visitor: FirVisitor, data: D): R = visitor.visitCallableReferenceAccess(this, data) } \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirClassReferenceExpression.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirClassReferenceExpression.kt index 9a9aad218b1..bf58a60b301 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirClassReferenceExpression.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirClassReferenceExpression.kt @@ -6,15 +6,11 @@ package org.jetbrains.kotlin.fir.expressions import com.intellij.psi.PsiElement -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.expressions.impl.FirUnknownTypeExpression import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.fir.visitors.FirVisitor -abstract class FirClassReferenceExpression( - session: FirSession, - psi: PsiElement? -) : FirUnknownTypeExpression(session, psi) { +abstract class FirClassReferenceExpression(psi: PsiElement?) : FirUnknownTypeExpression(psi) { abstract val classTypeRef: FirTypeRef override fun accept(visitor: FirVisitor, data: D): R = diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirComponentCall.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirComponentCall.kt index 90cc050edd3..bfcada7851e 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirComponentCall.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirComponentCall.kt @@ -6,13 +6,9 @@ package org.jetbrains.kotlin.fir.expressions import com.intellij.psi.PsiElement -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.visitors.FirVisitor -abstract class FirComponentCall( - session: FirSession, - psi: PsiElement? -) : FirFunctionCall(session, psi) { +abstract class FirComponentCall(psi: PsiElement?) : FirFunctionCall(psi) { // Starting from 1, not from 0 abstract val componentIndex: Int diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirConstExpression.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirConstExpression.kt index 821070f17a6..2367543bd06 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirConstExpression.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirConstExpression.kt @@ -6,15 +6,11 @@ package org.jetbrains.kotlin.fir.expressions import com.intellij.psi.PsiElement -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.expressions.impl.FirUnknownTypeExpression import org.jetbrains.kotlin.fir.visitors.FirVisitor import org.jetbrains.kotlin.ir.expressions.IrConstKind -abstract class FirConstExpression( - session: FirSession, - psi: PsiElement? -) : FirUnknownTypeExpression(session, psi) { +abstract class FirConstExpression(psi: PsiElement?) : FirUnknownTypeExpression(psi) { abstract val kind: IrConstKind abstract val value: T diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirContinueExpression.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirContinueExpression.kt index 2a300284dbb..9d0e4962cbf 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirContinueExpression.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirContinueExpression.kt @@ -6,14 +6,10 @@ package org.jetbrains.kotlin.fir.expressions import com.intellij.psi.PsiElement -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.expressions.impl.FirLoopJump import org.jetbrains.kotlin.fir.visitors.FirVisitor -abstract class FirContinueExpression( - session: FirSession, - psi: PsiElement? -) : FirLoopJump(session, psi) { +abstract class FirContinueExpression(psi: PsiElement?) : FirLoopJump(psi) { override fun accept(visitor: FirVisitor, data: D): R = visitor.visitContinueExpression(this, data) } \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirDelegatedConstructorCall.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirDelegatedConstructorCall.kt index aae24390fac..c2fec4832ea 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirDelegatedConstructorCall.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirDelegatedConstructorCall.kt @@ -6,16 +6,14 @@ package org.jetbrains.kotlin.fir.expressions import com.intellij.psi.PsiElement -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.VisitedSupertype import org.jetbrains.kotlin.fir.expressions.impl.FirCallWithArgumentList import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.fir.visitors.FirVisitor abstract class FirDelegatedConstructorCall( - session: FirSession, psi: PsiElement? -) : @VisitedSupertype FirCallWithArgumentList(session, psi), FirQualifiedAccess { +) : @VisitedSupertype FirCallWithArgumentList(psi), FirQualifiedAccess { // Do we need 'constructedType: FirType' here? abstract val constructedTypeRef: FirTypeRef diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirErrorExpression.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirErrorExpression.kt index 66c145bd217..daee98a77c3 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirErrorExpression.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirErrorExpression.kt @@ -6,14 +6,10 @@ package org.jetbrains.kotlin.fir.expressions import com.intellij.psi.PsiElement -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.expressions.impl.FirUnknownTypeExpression import org.jetbrains.kotlin.fir.visitors.FirVisitor -abstract class FirErrorExpression( - session: FirSession, - psi: PsiElement? -) : FirUnknownTypeExpression(session, psi) { +abstract class FirErrorExpression(psi: PsiElement?) : FirUnknownTypeExpression(psi) { abstract val reason: String override fun accept(visitor: FirVisitor, data: D): R { diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirExpression.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirExpression.kt index f7429942ce9..757d491ea2d 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirExpression.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirExpression.kt @@ -7,16 +7,14 @@ package org.jetbrains.kotlin.fir.expressions import com.intellij.psi.PsiElement 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.symbols.ConeCallableSymbol import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.fir.visitors.FirVisitor abstract class FirExpression( - session: FirSession, psi: PsiElement? -) : FirAnnotatedStatement(session, psi) { +) : FirAnnotatedStatement(psi) { abstract val typeRef: FirTypeRef abstract fun replaceTypeRef(newTypeRef: FirTypeRef) diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirFunctionCall.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirFunctionCall.kt index d155b7c970b..132f89f88b9 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirFunctionCall.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirFunctionCall.kt @@ -14,9 +14,8 @@ import org.jetbrains.kotlin.fir.types.FirTypeProjectionContainer import org.jetbrains.kotlin.fir.visitors.FirVisitor abstract class FirFunctionCall( - session: FirSession, psi: PsiElement? -) : @VisitedSupertype FirUnknownTypeCallWithArgumentList(session, psi), FirQualifiedAccess, FirTypeProjectionContainer { +) : @VisitedSupertype FirUnknownTypeCallWithArgumentList(psi), FirQualifiedAccess, FirTypeProjectionContainer { abstract override val calleeReference: FirNamedReference override fun accept(visitor: FirVisitor, data: D): R = diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirGetClassCall.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirGetClassCall.kt index f43c20de1e7..e41d0072a09 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirGetClassCall.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirGetClassCall.kt @@ -6,14 +6,10 @@ package org.jetbrains.kotlin.fir.expressions import com.intellij.psi.PsiElement -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.expressions.impl.FirUnknownTypeCallWithArgumentList import org.jetbrains.kotlin.fir.visitors.FirVisitor -abstract class FirGetClassCall( - session: FirSession, - psi: PsiElement? -) : FirUnknownTypeCallWithArgumentList(session, psi) { +abstract class FirGetClassCall(psi: PsiElement?) : FirUnknownTypeCallWithArgumentList(psi) { val argument: FirExpression get() = arguments.first() override fun accept(visitor: FirVisitor, data: D): R = diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirJump.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirJump.kt index 407a073b135..750a74295d9 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirJump.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirJump.kt @@ -6,15 +6,11 @@ package org.jetbrains.kotlin.fir.expressions import com.intellij.psi.PsiElement -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.FirTarget import org.jetbrains.kotlin.fir.FirTargetElement import org.jetbrains.kotlin.fir.visitors.FirVisitor -abstract class FirJump( - session: FirSession, - psi: PsiElement? -) : FirExpression(session, psi) { +abstract class FirJump(psi: PsiElement?) : FirExpression(psi) { abstract val target: FirTarget override fun accept(visitor: FirVisitor, data: D): R = diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirLambdaArgumentExpression.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirLambdaArgumentExpression.kt index d2ce7042e3e..513b68f2188 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirLambdaArgumentExpression.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirLambdaArgumentExpression.kt @@ -6,13 +6,9 @@ package org.jetbrains.kotlin.fir.expressions import com.intellij.psi.PsiElement -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.visitors.FirVisitor -abstract class FirLambdaArgumentExpression( - session: FirSession, - psi: PsiElement? -) : FirWrappedArgumentExpression(session, psi) { +abstract class FirLambdaArgumentExpression(psi: PsiElement?) : FirWrappedArgumentExpression(psi) { override fun accept(visitor: FirVisitor, data: D): R = visitor.visitLambdaArgumentExpression(this, data) } \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirNamedArgumentExpression.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirNamedArgumentExpression.kt index 400454524d1..8e56278ea16 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirNamedArgumentExpression.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirNamedArgumentExpression.kt @@ -6,14 +6,12 @@ package org.jetbrains.kotlin.fir.expressions import com.intellij.psi.PsiElement -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.visitors.FirVisitor import org.jetbrains.kotlin.name.Name abstract class FirNamedArgumentExpression( - session: FirSession, psi: PsiElement? -) : FirWrappedArgumentExpression(session, psi) { +) : FirWrappedArgumentExpression(psi) { abstract val name: Name override fun accept(visitor: FirVisitor, data: D): R = diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirOperatorCall.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirOperatorCall.kt index ae11f2af733..0becfe4de2f 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirOperatorCall.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirOperatorCall.kt @@ -6,14 +6,10 @@ package org.jetbrains.kotlin.fir.expressions import com.intellij.psi.PsiElement -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.expressions.impl.FirCallWithArgumentList import org.jetbrains.kotlin.fir.visitors.FirVisitor -abstract class FirOperatorCall( - session: FirSession, - psi: PsiElement? -) : FirCallWithArgumentList(session, psi) { +abstract class FirOperatorCall(psi: PsiElement?) : FirCallWithArgumentList(psi) { abstract val operation: FirOperation override fun accept(visitor: FirVisitor, data: D): R = diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirQualifiedAccessExpression.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirQualifiedAccessExpression.kt index 7186d1aa511..0ad7c2db471 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirQualifiedAccessExpression.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirQualifiedAccessExpression.kt @@ -6,15 +6,13 @@ package org.jetbrains.kotlin.fir.expressions import com.intellij.psi.PsiElement -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.VisitedSupertype import org.jetbrains.kotlin.fir.expressions.impl.FirUnknownTypeExpression import org.jetbrains.kotlin.fir.visitors.FirVisitor abstract class FirQualifiedAccessExpression( - session: FirSession, psi: PsiElement? -) : FirQualifiedAccess, @VisitedSupertype FirUnknownTypeExpression(session, psi) { +) : FirQualifiedAccess, @VisitedSupertype FirUnknownTypeExpression(psi) { override fun accept(visitor: FirVisitor, data: D): R = visitor.visitQualifiedAccessExpression(this, data) diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirResolvedQualifier.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirResolvedQualifier.kt index 6f93d8f6de5..836ba99c2bf 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirResolvedQualifier.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirResolvedQualifier.kt @@ -6,16 +6,12 @@ package org.jetbrains.kotlin.fir.expressions import com.intellij.psi.PsiElement -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.expressions.impl.FirUnknownTypeExpression import org.jetbrains.kotlin.fir.visitors.FirVisitor import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.FqName -abstract class FirResolvedQualifier( - session: FirSession, - psi: PsiElement? -) : FirUnknownTypeExpression(session, psi) { +abstract class FirResolvedQualifier(psi: PsiElement?) : FirUnknownTypeExpression(psi) { abstract val packageFqName: FqName abstract val relativeClassFqName: FqName? diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirReturnExpression.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirReturnExpression.kt index 58bfff4ec03..c33cbe1cf58 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirReturnExpression.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirReturnExpression.kt @@ -6,14 +6,10 @@ package org.jetbrains.kotlin.fir.expressions import com.intellij.psi.PsiElement -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.declarations.FirFunction import org.jetbrains.kotlin.fir.visitors.FirVisitor -abstract class FirReturnExpression( - session: FirSession, - psi: PsiElement? -) : FirJump(session, psi) { +abstract class FirReturnExpression(psi: PsiElement?) : FirJump(psi) { abstract val result: FirExpression override fun accept(visitor: FirVisitor, data: D): R = diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirSpreadArgumentExpression.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirSpreadArgumentExpression.kt index 796eab5e6fe..99b410dc556 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirSpreadArgumentExpression.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirSpreadArgumentExpression.kt @@ -6,13 +6,9 @@ package org.jetbrains.kotlin.fir.expressions import com.intellij.psi.PsiElement -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.visitors.FirVisitor -abstract class FirSpreadArgumentExpression( - session: FirSession, - psi: PsiElement? -) : FirWrappedArgumentExpression(session, psi) { +abstract class FirSpreadArgumentExpression(psi: PsiElement?) : FirWrappedArgumentExpression(psi) { override val isSpread: Boolean get() = true diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirStringConcatenationCall.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirStringConcatenationCall.kt index 33f4d061a79..17c22ae9036 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirStringConcatenationCall.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirStringConcatenationCall.kt @@ -6,14 +6,10 @@ package org.jetbrains.kotlin.fir.expressions import com.intellij.psi.PsiElement -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.expressions.impl.FirCallWithArgumentList import org.jetbrains.kotlin.fir.visitors.FirVisitor -abstract class FirStringConcatenationCall( - session: FirSession, - psi: PsiElement? -) : FirCallWithArgumentList(session, psi) { +abstract class FirStringConcatenationCall(psi: PsiElement?) : FirCallWithArgumentList(psi) { override fun accept(visitor: FirVisitor, data: D): R = visitor.visitStringConcatenationCall(this, data) } \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirThrowExpression.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirThrowExpression.kt index e0adbba79da..806486cd1e7 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirThrowExpression.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirThrowExpression.kt @@ -6,13 +6,9 @@ package org.jetbrains.kotlin.fir.expressions import com.intellij.psi.PsiElement -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.visitors.FirVisitor -abstract class FirThrowExpression( - session: FirSession, - psi: PsiElement? -) : FirExpression(session, psi) { +abstract class FirThrowExpression(psi: PsiElement?) : FirExpression(psi) { abstract val exception: FirExpression override fun accept(visitor: FirVisitor, data: D): R = diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirTryExpression.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirTryExpression.kt index 37f5724b0c7..3f9919a8d4e 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirTryExpression.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirTryExpression.kt @@ -6,14 +6,12 @@ package org.jetbrains.kotlin.fir.expressions import com.intellij.psi.PsiElement -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.expressions.impl.FirUnknownTypeExpression import org.jetbrains.kotlin.fir.visitors.FirVisitor abstract class FirTryExpression( - session: FirSession, psi: PsiElement? -) : FirUnknownTypeExpression(session, psi) { +) : FirUnknownTypeExpression(psi) { abstract val tryBlock: FirBlock abstract val catches: List diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirTypeOperatorCall.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirTypeOperatorCall.kt index 74f0e9c3da4..8c730f4422c 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirTypeOperatorCall.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirTypeOperatorCall.kt @@ -6,17 +6,15 @@ package org.jetbrains.kotlin.fir.expressions import com.intellij.psi.PsiElement -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.expressions.impl.FirOperationBasedCall import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.fir.visitors.FirVisitor // is/!is/as/as? abstract class FirTypeOperatorCall( - session: FirSession, psi: PsiElement?, operation: FirOperation -) : FirOperationBasedCall(session, psi, operation) { +) : FirOperationBasedCall(psi, operation) { val argument: FirExpression get() = arguments.first() abstract val conversionTypeRef: FirTypeRef diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirUncheckedNotNullCast.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirUncheckedNotNullCast.kt index 394124848e5..511616fb6b8 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirUncheckedNotNullCast.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirUncheckedNotNullCast.kt @@ -6,14 +6,10 @@ package org.jetbrains.kotlin.fir.expressions import com.intellij.psi.PsiElement -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.expressions.impl.FirUnknownTypeCallWithArgumentList import org.jetbrains.kotlin.fir.visitors.FirVisitor -abstract class FirUncheckedNotNullCast( - session: FirSession, - psi: PsiElement? -) : FirUnknownTypeCallWithArgumentList(session, psi) { +abstract class FirUncheckedNotNullCast(psi: PsiElement?) : FirUnknownTypeCallWithArgumentList(psi) { override fun accept(visitor: FirVisitor, data: D): R = visitor.visitUncheckedNotNullCast(this, data) val expression: FirExpression get() = arguments[0] diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirWhenExpression.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirWhenExpression.kt index 6c58ac90115..1349531fbd7 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirWhenExpression.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirWhenExpression.kt @@ -6,14 +6,10 @@ package org.jetbrains.kotlin.fir.expressions import com.intellij.psi.PsiElement -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.expressions.impl.FirUnknownTypeExpression import org.jetbrains.kotlin.fir.visitors.FirVisitor -abstract class FirWhenExpression( - session: FirSession, - psi: PsiElement? -) : FirUnknownTypeExpression(session, psi) { +abstract class FirWhenExpression(psi: PsiElement?) : FirUnknownTypeExpression(psi) { abstract val subject: FirExpression? // when (val subjectVariable = subject()) { ... } diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirWhenSubjectExpression.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirWhenSubjectExpression.kt index 3ea365f3ad2..64a775d6c32 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirWhenSubjectExpression.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirWhenSubjectExpression.kt @@ -6,15 +6,11 @@ package org.jetbrains.kotlin.fir.expressions import com.intellij.psi.PsiElement -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.FirWhenSubject import org.jetbrains.kotlin.fir.expressions.impl.FirUnknownTypeExpression import org.jetbrains.kotlin.fir.visitors.FirVisitor -abstract class FirWhenSubjectExpression( - session: FirSession, - psi: PsiElement? -) : FirUnknownTypeExpression(session, psi) { +abstract class FirWhenSubjectExpression(psi: PsiElement?) : FirUnknownTypeExpression(psi) { abstract val whenSubject: FirWhenSubject override fun accept(visitor: FirVisitor, data: D): R = diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirWrappedArgumentExpression.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirWrappedArgumentExpression.kt index 56f7bdb50b7..c542e5c587a 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirWrappedArgumentExpression.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirWrappedArgumentExpression.kt @@ -6,14 +6,10 @@ package org.jetbrains.kotlin.fir.expressions import com.intellij.psi.PsiElement -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.fir.visitors.FirVisitor -abstract class FirWrappedArgumentExpression( - session: FirSession, - psi: PsiElement? -) : FirWrappedExpression(session, psi) { +abstract class FirWrappedArgumentExpression(psi: PsiElement?) : FirWrappedExpression(psi) { open val isSpread: Boolean get() = false diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirWrappedDelegateExpression.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirWrappedDelegateExpression.kt index be8bc0d1a90..c63462edc82 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirWrappedDelegateExpression.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirWrappedDelegateExpression.kt @@ -6,14 +6,10 @@ package org.jetbrains.kotlin.fir.expressions import com.intellij.psi.PsiElement -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.fir.visitors.FirVisitor -abstract class FirWrappedDelegateExpression( - session: FirSession, - psi: PsiElement? -) : FirWrappedExpression(session, psi) { +abstract class FirWrappedDelegateExpression(psi: PsiElement?) : FirWrappedExpression(psi) { abstract val delegateProvider: FirExpression override val typeRef: FirTypeRef diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirWrappedExpression.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirWrappedExpression.kt index bb6c0fcc8fa..94021465772 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirWrappedExpression.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirWrappedExpression.kt @@ -6,14 +6,10 @@ package org.jetbrains.kotlin.fir.expressions import com.intellij.psi.PsiElement -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.fir.visitors.FirVisitor -abstract class FirWrappedExpression( - session: FirSession, - psi: PsiElement? -) : FirExpression(session, psi) { +abstract class FirWrappedExpression(psi: PsiElement?) : FirExpression(psi) { abstract val expression: FirExpression override fun replaceTypeRef(newTypeRef: FirTypeRef) { diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirAbstractAnnotatedElement.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirAbstractAnnotatedElement.kt index ccbe460caf2..ca52d801424 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirAbstractAnnotatedElement.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirAbstractAnnotatedElement.kt @@ -8,16 +8,12 @@ package org.jetbrains.kotlin.fir.expressions.impl import com.intellij.psi.PsiElement import org.jetbrains.kotlin.fir.FirAbstractElement 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.FirAnnotationContainer import org.jetbrains.kotlin.fir.transformInplace import org.jetbrains.kotlin.fir.visitors.FirTransformer -abstract class FirAbstractAnnotatedElement( - session: FirSession, - psi: PsiElement? -) : FirAbstractElement(session, psi), FirAnnotationContainer { +abstract class FirAbstractAnnotatedElement(psi: PsiElement?) : FirAbstractElement(psi), FirAnnotationContainer { final override val annotations = mutableListOf() override fun transformChildren(transformer: FirTransformer, data: D): FirElement { diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirAbstractAssignment.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirAbstractAssignment.kt index 48b4d333754..21493bfbfe1 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirAbstractAssignment.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirAbstractAssignment.kt @@ -8,7 +8,6 @@ package org.jetbrains.kotlin.fir.expressions.impl import com.intellij.psi.PsiElement import org.jetbrains.kotlin.fir.FirElement 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.FirExpression import org.jetbrains.kotlin.fir.expressions.FirOperation @@ -17,12 +16,11 @@ import org.jetbrains.kotlin.fir.transformSingle import org.jetbrains.kotlin.fir.visitors.FirTransformer abstract class FirAbstractAssignment( - session: FirSession, psi: PsiElement?, final override var rValue: FirExpression, final override val operation: FirOperation, safe: Boolean = false -) : FirAbstractQualifiedAccess(session, psi, safe), FirVariableAssignment { +) : FirAbstractQualifiedAccess(psi, safe), FirVariableAssignment { override var lValue: FirReference get() = calleeReference diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirAbstractLoop.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirAbstractLoop.kt index 1627b424cc1..6317ba836c7 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirAbstractLoop.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirAbstractLoop.kt @@ -13,10 +13,9 @@ import org.jetbrains.kotlin.fir.expressions.FirLoop import org.jetbrains.kotlin.fir.visitors.FirTransformer abstract class FirAbstractLoop( - session: FirSession, psi: PsiElement?, override var condition: FirExpression -) : FirAnnotatedStatement(session, psi), FirLoop { +) : FirAnnotatedStatement(psi), FirLoop { override lateinit var block: FirBlock override var label: FirLabel? = null diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirAbstractQualifiedAccess.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirAbstractQualifiedAccess.kt index 1b4e3b83c07..f53e258ccd1 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirAbstractQualifiedAccess.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirAbstractQualifiedAccess.kt @@ -12,10 +12,9 @@ import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccess import org.jetbrains.kotlin.fir.visitors.FirTransformer abstract class FirAbstractQualifiedAccess( - session: FirSession, psi: PsiElement?, final override var safe: Boolean = false -) : FirAnnotatedStatement(session, psi), FirModifiableQualifiedAccess { +) : FirAnnotatedStatement(psi), FirModifiableQualifiedAccess { final override lateinit var calleeReference: FirReference final override var explicitReceiver: FirExpression? = null diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirAnnotatedStatement.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirAnnotatedStatement.kt index a9529670e42..9607943a361 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirAnnotatedStatement.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirAnnotatedStatement.kt @@ -6,10 +6,6 @@ package org.jetbrains.kotlin.fir.expressions.impl import com.intellij.psi.PsiElement -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.expressions.FirStatement -abstract class FirAnnotatedStatement( - session: FirSession, - psi: PsiElement? -) : FirAbstractAnnotatedElement(session, psi), FirStatement \ No newline at end of file +abstract class FirAnnotatedStatement(psi: PsiElement?) : FirAbstractAnnotatedElement(psi), FirStatement \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirAnnotationCallImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirAnnotationCallImpl.kt index d68d4740096..ceb0e84537c 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirAnnotationCallImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirAnnotationCallImpl.kt @@ -8,18 +8,16 @@ package org.jetbrains.kotlin.fir.expressions.impl import com.intellij.psi.PsiElement import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget import org.jetbrains.kotlin.fir.FirElement -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.transformSingle import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.fir.visitors.FirTransformer class FirAnnotationCallImpl( - session: FirSession, psi: PsiElement?, override val useSiteTarget: AnnotationUseSiteTarget?, override var annotationTypeRef: FirTypeRef -) : FirAnnotationCall(session, psi) { +) : FirAnnotationCall(psi) { override val typeRef: FirTypeRef get() = annotationTypeRef diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirArrayOfCallImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirArrayOfCallImpl.kt index 41cba74b35f..a5acc2145a6 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirArrayOfCallImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirArrayOfCallImpl.kt @@ -6,10 +6,6 @@ package org.jetbrains.kotlin.fir.expressions.impl import com.intellij.psi.PsiElement -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.expressions.FirArrayOfCall -class FirArrayOfCallImpl( - session: FirSession, - psi: PsiElement? -) : FirArrayOfCall(session, psi) \ No newline at end of file +class FirArrayOfCallImpl(psi: PsiElement?) : FirArrayOfCall(psi) \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirArraySetCallImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirArraySetCallImpl.kt index 4b6385edd3d..db0750ba725 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirArraySetCallImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirArraySetCallImpl.kt @@ -13,11 +13,10 @@ import org.jetbrains.kotlin.fir.types.impl.FirImplicitTypeRefImpl import org.jetbrains.kotlin.fir.visitors.FirTransformer class FirArraySetCallImpl( - session: FirSession, psi: PsiElement?, override var rValue: FirExpression, override val operation: FirOperation -) : FirArraySetCall(session, psi), FirModifiableQualifiedAccess { +) : FirArraySetCall(psi), FirModifiableQualifiedAccess { override lateinit var calleeReference: FirReference override var lValue: FirReference @@ -30,7 +29,7 @@ class FirArraySetCallImpl( get() = null set(_) {} - override var typeRef: FirTypeRef = FirImplicitTypeRefImpl(session, null) + override var typeRef: FirTypeRef = FirImplicitTypeRefImpl(null) override fun replaceTypeRef(newTypeRef: FirTypeRef) { typeRef = newTypeRef diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirBlockImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirBlockImpl.kt index 4f396eb368a..f21dc99b1bf 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirBlockImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirBlockImpl.kt @@ -7,16 +7,12 @@ package org.jetbrains.kotlin.fir.expressions.impl import com.intellij.psi.PsiElement 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.FirStatement import org.jetbrains.kotlin.fir.transformInplace import org.jetbrains.kotlin.fir.visitors.FirTransformer -class FirBlockImpl( - session: FirSession, - psi: PsiElement? -) : FirBlock(session, psi) { +class FirBlockImpl(psi: PsiElement?) : FirBlock(psi) { override val statements = mutableListOf() override fun transformChildren(transformer: FirTransformer, data: D): FirElement { diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirBreakExpressionImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirBreakExpressionImpl.kt index b6a642eb323..1b5ea4b7573 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirBreakExpressionImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirBreakExpressionImpl.kt @@ -6,10 +6,6 @@ package org.jetbrains.kotlin.fir.expressions.impl import com.intellij.psi.PsiElement -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.expressions.FirBreakExpression -class FirBreakExpressionImpl( - session: FirSession, - psi: PsiElement? -) : FirBreakExpression(session, psi) \ No newline at end of file +class FirBreakExpressionImpl(psi: PsiElement?) : FirBreakExpression(psi) \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirCallWithArgumentList.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirCallWithArgumentList.kt index 00b0b44220e..7944633225d 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirCallWithArgumentList.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirCallWithArgumentList.kt @@ -7,16 +7,12 @@ package org.jetbrains.kotlin.fir.expressions.impl import com.intellij.psi.PsiElement 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.FirExpression import org.jetbrains.kotlin.fir.transformInplace import org.jetbrains.kotlin.fir.visitors.FirTransformer -abstract class FirCallWithArgumentList( - session: FirSession, - psi: PsiElement? -) : FirCall(session, psi) { +abstract class FirCallWithArgumentList(psi: PsiElement?) : FirCall(psi) { override val arguments = mutableListOf() override fun transformChildren(transformer: FirTransformer, data: D): FirElement { diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirCallableReferenceAccessImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirCallableReferenceAccessImpl.kt index 1bd8fcb8c59..a71126cdae8 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirCallableReferenceAccessImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirCallableReferenceAccessImpl.kt @@ -8,16 +8,14 @@ package org.jetbrains.kotlin.fir.expressions.impl import com.intellij.psi.PsiElement import org.jetbrains.kotlin.fir.FirElement 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.FirExpression import org.jetbrains.kotlin.fir.transformSingle import org.jetbrains.kotlin.fir.visitors.FirTransformer class FirCallableReferenceAccessImpl( - session: FirSession, psi: PsiElement? -) : FirCallableReferenceAccess(session, psi), FirModifiableQualifiedAccess { +) : FirCallableReferenceAccess(psi), FirModifiableQualifiedAccess { override lateinit var calleeReference: FirReference override var explicitReceiver: FirExpression? = null diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirCatchImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirCatchImpl.kt index db74406b5e1..e5eab3a4f35 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirCatchImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirCatchImpl.kt @@ -8,7 +8,6 @@ package org.jetbrains.kotlin.fir.expressions.impl import com.intellij.psi.PsiElement import org.jetbrains.kotlin.fir.FirAbstractElement import org.jetbrains.kotlin.fir.FirElement -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.declarations.FirValueParameter import org.jetbrains.kotlin.fir.expressions.FirBlock import org.jetbrains.kotlin.fir.expressions.FirCatch @@ -16,11 +15,10 @@ import org.jetbrains.kotlin.fir.transformSingle import org.jetbrains.kotlin.fir.visitors.FirTransformer class FirCatchImpl( - session: FirSession, psi: PsiElement?, override var parameter: FirValueParameter, override var block: FirBlock -) : FirAbstractElement(session, psi), FirCatch { +) : FirAbstractElement(psi), FirCatch { override fun transformChildren(transformer: FirTransformer, data: D): FirElement { parameter = parameter.transformSingle(transformer, data) block = block.transformSingle(transformer, data) diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirClassReferenceExpressionImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirClassReferenceExpressionImpl.kt index 6d532c1af9f..c1663d80dce 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirClassReferenceExpressionImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirClassReferenceExpressionImpl.kt @@ -7,17 +7,12 @@ package org.jetbrains.kotlin.fir.expressions.impl import com.intellij.psi.PsiElement import org.jetbrains.kotlin.fir.FirElement -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.expressions.FirClassReferenceExpression import org.jetbrains.kotlin.fir.transformSingle import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.fir.visitors.FirTransformer -class FirClassReferenceExpressionImpl( - session: FirSession, - psi: PsiElement?, - override var classTypeRef: FirTypeRef -) : FirClassReferenceExpression(session, psi) { +class FirClassReferenceExpressionImpl(psi: PsiElement?, override var classTypeRef: FirTypeRef) : FirClassReferenceExpression(psi) { override fun transformChildren(transformer: FirTransformer, data: D): FirElement { classTypeRef = classTypeRef.transformSingle(transformer, data) return super.transformChildren(transformer, data) diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirComponentCallImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirComponentCallImpl.kt index 7b3ac6d298e..9fc92cbecbd 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirComponentCallImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirComponentCallImpl.kt @@ -8,7 +8,6 @@ package org.jetbrains.kotlin.fir.expressions.impl import com.intellij.psi.PsiElement import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.FirNamedReference -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.expressions.FirComponentCall import org.jetbrains.kotlin.fir.expressions.FirExpression import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccess @@ -19,18 +18,17 @@ import org.jetbrains.kotlin.fir.visitors.FirTransformer import org.jetbrains.kotlin.name.Name class FirComponentCallImpl( - session: FirSession, psi: PsiElement?, override val componentIndex: Int, override var explicitReceiver: FirExpression -) : FirComponentCall(session, psi) { +) : FirComponentCall(psi) { override fun transformExplicitReceiver(transformer: FirTransformer, data: D): FirQualifiedAccess { explicitReceiver = explicitReceiver.transformSingle(transformer, data) return this } override var calleeReference: FirNamedReference = - FirSimpleNamedReference(session, psi, Name.identifier("component$componentIndex")) + FirSimpleNamedReference(psi, Name.identifier("component$componentIndex")) override val typeArguments: List get() = emptyList() diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirConstExpressionImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirConstExpressionImpl.kt index 78acad5b1a7..22f85deed8c 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirConstExpressionImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirConstExpressionImpl.kt @@ -6,16 +6,14 @@ package org.jetbrains.kotlin.fir.expressions.impl import com.intellij.psi.PsiElement -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.expressions.FirConstExpression import org.jetbrains.kotlin.ir.expressions.IrConstKind class FirConstExpressionImpl( - session: FirSession, psi: PsiElement?, override val kind: IrConstKind, override val value: T -) : FirConstExpression(session, psi) +) : FirConstExpression(psi) -fun FirConstExpressionImpl(session: FirSession, psi: PsiElement?, kind: IrConstKind, value: T?, errorReason: String) = - value?.let { FirConstExpressionImpl(session, psi, kind, it) } ?: FirErrorExpressionImpl(session, psi, errorReason) \ No newline at end of file +fun FirConstExpressionImpl(psi: PsiElement?, kind: IrConstKind, value: T?, errorReason: String) = + value?.let { FirConstExpressionImpl(psi, kind, it) } ?: FirErrorExpressionImpl(psi, errorReason) \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirContinueExpressionImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirContinueExpressionImpl.kt index b347e7f9283..cae3155aba4 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirContinueExpressionImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirContinueExpressionImpl.kt @@ -6,10 +6,6 @@ package org.jetbrains.kotlin.fir.expressions.impl import com.intellij.psi.PsiElement -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.expressions.FirContinueExpression -class FirContinueExpressionImpl( - session: FirSession, - psi: PsiElement? -) : FirContinueExpression(session, psi) \ No newline at end of file +class FirContinueExpressionImpl(psi: PsiElement?) : FirContinueExpression(psi) \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirDelegatedConstructorCallImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirDelegatedConstructorCallImpl.kt index 472757f370b..8187edbefe2 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirDelegatedConstructorCallImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirDelegatedConstructorCallImpl.kt @@ -8,7 +8,6 @@ package org.jetbrains.kotlin.fir.expressions.impl import com.intellij.psi.PsiElement import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.FirReference -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.expressions.FirDelegatedConstructorCall import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccess import org.jetbrains.kotlin.fir.references.FirExplicitSuperReference @@ -19,13 +18,12 @@ import org.jetbrains.kotlin.fir.types.impl.FirImplicitUnitTypeRef import org.jetbrains.kotlin.fir.visitors.FirTransformer class FirDelegatedConstructorCallImpl( - session: FirSession, psi: PsiElement?, override var constructedTypeRef: FirTypeRef, override val isThis: Boolean -) : FirDelegatedConstructorCall(session, psi) { +) : FirDelegatedConstructorCall(psi) { override var calleeReference: FirReference = - if (isThis) FirExplicitThisReference(session, psi, null) else FirExplicitSuperReference(session, psi, constructedTypeRef) + if (isThis) FirExplicitThisReference(psi, null) else FirExplicitSuperReference(psi, constructedTypeRef) override fun transformCalleeReference(transformer: FirTransformer, data: D): FirQualifiedAccess { calleeReference = calleeReference.transformSingle(transformer, data) @@ -44,7 +42,7 @@ class FirDelegatedConstructorCallImpl( return this } - override var typeRef: FirTypeRef = FirImplicitUnitTypeRef(session, psi) + override var typeRef: FirTypeRef = FirImplicitUnitTypeRef(psi) override fun replaceTypeRef(newTypeRef: FirTypeRef) {} } \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirDoWhileLoopImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirDoWhileLoopImpl.kt index ed30a238364..1bfc062e315 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirDoWhileLoopImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirDoWhileLoopImpl.kt @@ -6,12 +6,7 @@ package org.jetbrains.kotlin.fir.expressions.impl import com.intellij.psi.PsiElement -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.expressions.FirDoWhileLoop import org.jetbrains.kotlin.fir.expressions.FirExpression -class FirDoWhileLoopImpl( - session: FirSession, - psi: PsiElement?, - condition: FirExpression -) : FirAbstractLoop(session, psi, condition), FirDoWhileLoop \ No newline at end of file +class FirDoWhileLoopImpl(psi: PsiElement?, condition: FirExpression) : FirAbstractLoop(psi, condition), FirDoWhileLoop \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirElseIfTrueCondition.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirElseIfTrueCondition.kt index 59020312090..88a0b584f5e 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirElseIfTrueCondition.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirElseIfTrueCondition.kt @@ -7,7 +7,6 @@ package org.jetbrains.kotlin.fir.expressions.impl import com.intellij.psi.PsiElement import org.jetbrains.kotlin.fir.FirElement -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.expressions.FirExpression import org.jetbrains.kotlin.fir.transformSingle import org.jetbrains.kotlin.fir.types.FirTypeRef @@ -15,12 +14,9 @@ import org.jetbrains.kotlin.fir.types.impl.FirImplicitUnitTypeRef import org.jetbrains.kotlin.fir.visitors.FirTransformer // Representation of "dummy" condition at else branch -class FirElseIfTrueCondition( - session: FirSession, - psi: PsiElement? -) : FirExpression(session, psi) { +class FirElseIfTrueCondition(psi: PsiElement?) : FirExpression(psi) { - override var typeRef: FirTypeRef = FirImplicitUnitTypeRef(session, psi) + override var typeRef: FirTypeRef = FirImplicitUnitTypeRef(psi) override fun replaceTypeRef(newTypeRef: FirTypeRef) {} diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirEmptyExpressionBlock.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirEmptyExpressionBlock.kt index 39124ca6ef6..cc01c156441 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirEmptyExpressionBlock.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirEmptyExpressionBlock.kt @@ -5,12 +5,9 @@ package org.jetbrains.kotlin.fir.expressions.impl -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.expressions.FirBlock import org.jetbrains.kotlin.fir.expressions.FirStatement -class FirEmptyExpressionBlock( - session: FirSession -) : FirBlock(session, null) { +class FirEmptyExpressionBlock : FirBlock(null) { override val statements: List = listOf() } \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirErrorExpressionImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirErrorExpressionImpl.kt index 65d833b3074..c566bfad375 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirErrorExpressionImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirErrorExpressionImpl.kt @@ -10,7 +10,6 @@ import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.expressions.FirErrorExpression class FirErrorExpressionImpl( - session: FirSession, psi: PsiElement?, override val reason: String -) : FirErrorExpression(session, psi) \ No newline at end of file +) : FirErrorExpression(psi) \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirExpressionStub.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirExpressionStub.kt index 3296cf7d2fa..29871f57d94 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirExpressionStub.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirExpressionStub.kt @@ -6,9 +6,5 @@ package org.jetbrains.kotlin.fir.expressions.impl import com.intellij.psi.PsiElement -import org.jetbrains.kotlin.fir.FirSession -class FirExpressionStub( - session: FirSession, - psi: PsiElement? -) : FirUnknownTypeExpression(session, psi) \ No newline at end of file +class FirExpressionStub(psi: PsiElement?) : FirUnknownTypeExpression(psi) \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirFunctionCallImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirFunctionCallImpl.kt index 81a4888ccf7..35a438a8bd2 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirFunctionCallImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirFunctionCallImpl.kt @@ -14,10 +14,9 @@ import org.jetbrains.kotlin.fir.types.FirTypeProjection import org.jetbrains.kotlin.fir.visitors.FirTransformer class FirFunctionCallImpl( - session: FirSession, psi: PsiElement?, override var safe: Boolean = false -) : FirFunctionCall(session, psi), FirModifiableQualifiedAccess { +) : FirFunctionCall(psi), FirModifiableQualifiedAccess { override val typeArguments = mutableListOf() override lateinit var calleeReference: FirNamedReference diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirGetClassCallImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirGetClassCallImpl.kt index 9be05bbaa66..5305ed5c4fa 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirGetClassCallImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirGetClassCallImpl.kt @@ -6,10 +6,6 @@ package org.jetbrains.kotlin.fir.expressions.impl import com.intellij.psi.PsiElement -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.expressions.FirGetClassCall -class FirGetClassCallImpl( - session: FirSession, - psi: PsiElement? -) : FirGetClassCall(session, psi) \ No newline at end of file +class FirGetClassCallImpl(psi: PsiElement?) : FirGetClassCall(psi) \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirLambdaArgumentExpressionImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirLambdaArgumentExpressionImpl.kt index 106308f6a8e..e8ce20693f5 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirLambdaArgumentExpressionImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirLambdaArgumentExpressionImpl.kt @@ -7,17 +7,15 @@ package org.jetbrains.kotlin.fir.expressions.impl import com.intellij.psi.PsiElement import org.jetbrains.kotlin.fir.FirElement -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.expressions.FirExpression import org.jetbrains.kotlin.fir.expressions.FirLambdaArgumentExpression import org.jetbrains.kotlin.fir.transformSingle import org.jetbrains.kotlin.fir.visitors.FirTransformer class FirLambdaArgumentExpressionImpl( - session: FirSession, psi: PsiElement?, override var expression: FirExpression -) : FirLambdaArgumentExpression(session, psi) { +) : FirLambdaArgumentExpression(psi) { override fun transformChildren(transformer: FirTransformer, data: D): FirElement { expression = expression.transformSingle(transformer, data) return super.transformChildren(transformer, data) diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirLoopJump.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirLoopJump.kt index 0424b1edb16..d75ec24e197 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirLoopJump.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirLoopJump.kt @@ -7,7 +7,6 @@ package org.jetbrains.kotlin.fir.expressions.impl import com.intellij.psi.PsiElement import org.jetbrains.kotlin.fir.FirElement -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.FirTarget import org.jetbrains.kotlin.fir.expressions.FirJump import org.jetbrains.kotlin.fir.expressions.FirLoop @@ -16,13 +15,10 @@ import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.fir.types.impl.FirImplicitNothingTypeRef import org.jetbrains.kotlin.fir.visitors.FirTransformer -abstract class FirLoopJump( - session: FirSession, - psi: PsiElement? -) : FirJump(session, psi) { +abstract class FirLoopJump(psi: PsiElement?) : FirJump(psi) { override lateinit var target: FirTarget - override var typeRef: FirTypeRef = FirImplicitNothingTypeRef(session, psi) + override var typeRef: FirTypeRef = FirImplicitNothingTypeRef(psi) override fun replaceTypeRef(newTypeRef: FirTypeRef) {} diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirNamedArgumentExpressionImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirNamedArgumentExpressionImpl.kt index ac703b591a7..78d77341bc3 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirNamedArgumentExpressionImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirNamedArgumentExpressionImpl.kt @@ -7,7 +7,6 @@ package org.jetbrains.kotlin.fir.expressions.impl import com.intellij.psi.PsiElement import org.jetbrains.kotlin.fir.FirElement -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.expressions.FirExpression import org.jetbrains.kotlin.fir.expressions.FirNamedArgumentExpression import org.jetbrains.kotlin.fir.transformSingle @@ -15,12 +14,11 @@ import org.jetbrains.kotlin.fir.visitors.FirTransformer import org.jetbrains.kotlin.name.Name class FirNamedArgumentExpressionImpl( - session: FirSession, psi: PsiElement?, override val name: Name, override val isSpread: Boolean, override var expression: FirExpression -) : FirNamedArgumentExpression(session, psi) { +) : FirNamedArgumentExpression(psi) { override fun transformChildren(transformer: FirTransformer, data: D): FirElement { expression = expression.transformSingle(transformer, data) return super.transformChildren(transformer, data) diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirOperationBasedCall.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirOperationBasedCall.kt index 2983afd99ff..73d21037942 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirOperationBasedCall.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirOperationBasedCall.kt @@ -7,7 +7,6 @@ package org.jetbrains.kotlin.fir.expressions.impl import com.intellij.psi.PsiElement import org.jetbrains.kotlin.fir.FirElement -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.expressions.FirOperation import org.jetbrains.kotlin.fir.expressions.FirOperatorCall import org.jetbrains.kotlin.fir.transformSingle @@ -17,14 +16,13 @@ import org.jetbrains.kotlin.fir.types.impl.FirImplicitTypeRefImpl import org.jetbrains.kotlin.fir.visitors.FirTransformer abstract class FirOperationBasedCall( - session: FirSession, psi: PsiElement?, final override val operation: FirOperation -) : FirOperatorCall(session, psi) { +) : FirOperatorCall(psi) { override var typeRef: FirTypeRef = if (operation in FirOperation.BOOLEANS) { - FirImplicitBooleanTypeRef(session, null) + FirImplicitBooleanTypeRef(null) } else { - FirImplicitTypeRefImpl(session, null) + FirImplicitTypeRefImpl(null) } override fun replaceTypeRef(newTypeRef: FirTypeRef) { diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirOperatorCallImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirOperatorCallImpl.kt index 9c0ac651973..735d87445e0 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirOperatorCallImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirOperatorCallImpl.kt @@ -6,11 +6,9 @@ package org.jetbrains.kotlin.fir.expressions.impl import com.intellij.psi.PsiElement -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.expressions.FirOperation class FirOperatorCallImpl( - session: FirSession, psi: PsiElement?, operation: FirOperation -) : FirOperationBasedCall(session, psi, operation) \ No newline at end of file +) : FirOperationBasedCall(psi, operation) \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirQualifiedAccessExpressionImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirQualifiedAccessExpressionImpl.kt index 340d0c12247..526e1820efb 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirQualifiedAccessExpressionImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirQualifiedAccessExpressionImpl.kt @@ -8,17 +8,15 @@ package org.jetbrains.kotlin.fir.expressions.impl import com.intellij.psi.PsiElement import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.FirReference -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.expressions.FirExpression import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessExpression import org.jetbrains.kotlin.fir.transformSingle import org.jetbrains.kotlin.fir.visitors.FirTransformer class FirQualifiedAccessExpressionImpl( - session: FirSession, psi: PsiElement?, override var safe: Boolean = false -) : FirModifiableQualifiedAccess, FirQualifiedAccessExpression(session, psi) { +) : FirModifiableQualifiedAccess, FirQualifiedAccessExpression(psi) { override lateinit var calleeReference: FirReference override var explicitReceiver: FirExpression? = null diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirResolvedQualifierImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirResolvedQualifierImpl.kt index 581b129fb10..d168dc75810 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirResolvedQualifierImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirResolvedQualifierImpl.kt @@ -6,21 +6,14 @@ package org.jetbrains.kotlin.fir.expressions.impl import com.intellij.psi.PsiElement -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.expressions.FirResolvedQualifier import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.FqName class FirResolvedQualifierImpl( - session: FirSession, psi: PsiElement?, override val packageFqName: FqName, override val relativeClassFqName: FqName? -) : FirResolvedQualifier(session, psi) { - constructor(session: FirSession, psi: PsiElement?, classId: ClassId) : this( - session, - psi, - classId.packageFqName, - classId.relativeClassName - ) +) : FirResolvedQualifier(psi) { + constructor(psi: PsiElement?, classId: ClassId) : this(psi, classId.packageFqName, classId.relativeClassName) } \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirReturnExpressionImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirReturnExpressionImpl.kt index 2f1499b79b5..c4afdb6860c 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirReturnExpressionImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirReturnExpressionImpl.kt @@ -15,10 +15,9 @@ import org.jetbrains.kotlin.fir.types.impl.FirImplicitNothingTypeRef import org.jetbrains.kotlin.fir.visitors.FirTransformer class FirReturnExpressionImpl( - session: FirSession, psi: PsiElement?, override var result: FirExpression -) : FirReturnExpression(session, psi) { +) : FirReturnExpression(psi) { override lateinit var target: FirTarget override fun transformChildren(transformer: FirTransformer, data: D): FirElement { @@ -27,7 +26,7 @@ class FirReturnExpressionImpl( return super.transformChildren(transformer, data) } - override var typeRef: FirTypeRef = FirImplicitNothingTypeRef(session, psi) + override var typeRef: FirTypeRef = FirImplicitNothingTypeRef(psi) override fun replaceTypeRef(newTypeRef: FirTypeRef) {} } \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirSingleExpressionBlock.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirSingleExpressionBlock.kt index 52e39e9dd82..c8b2f840de8 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirSingleExpressionBlock.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirSingleExpressionBlock.kt @@ -6,16 +6,12 @@ package org.jetbrains.kotlin.fir.expressions.impl 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.FirStatement import org.jetbrains.kotlin.fir.transformSingle import org.jetbrains.kotlin.fir.visitors.FirTransformer -class FirSingleExpressionBlock( - session: FirSession, - private var statement: FirStatement -) : FirBlock(session, statement.psi) { +class FirSingleExpressionBlock(private var statement: FirStatement) : FirBlock(statement.psi) { override val statements get() = listOf(statement) diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirSpreadArgumentExpressionImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirSpreadArgumentExpressionImpl.kt index 2321fe53671..889d3c76698 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirSpreadArgumentExpressionImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirSpreadArgumentExpressionImpl.kt @@ -7,17 +7,15 @@ package org.jetbrains.kotlin.fir.expressions.impl import com.intellij.psi.PsiElement import org.jetbrains.kotlin.fir.FirElement -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.expressions.FirExpression import org.jetbrains.kotlin.fir.expressions.FirSpreadArgumentExpression import org.jetbrains.kotlin.fir.transformSingle import org.jetbrains.kotlin.fir.visitors.FirTransformer class FirSpreadArgumentExpressionImpl( - session: FirSession, psi: PsiElement?, override var expression: FirExpression -) : FirSpreadArgumentExpression(session, psi) { +) : FirSpreadArgumentExpression(psi) { override fun transformChildren(transformer: FirTransformer, data: D): FirElement { expression = expression.transformSingle(transformer, data) return super.transformChildren(transformer, data) diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirStringConcatenationCallImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirStringConcatenationCallImpl.kt index 0ee6620b53e..2b63285a0d2 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirStringConcatenationCallImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirStringConcatenationCallImpl.kt @@ -7,20 +7,16 @@ package org.jetbrains.kotlin.fir.expressions.impl import com.intellij.psi.PsiElement import org.jetbrains.kotlin.fir.FirElement -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.expressions.FirStringConcatenationCall import org.jetbrains.kotlin.fir.transformSingle import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.fir.types.impl.FirImplicitStringTypeRef import org.jetbrains.kotlin.fir.visitors.FirTransformer -class FirStringConcatenationCallImpl( - session: FirSession, - psi: PsiElement? -) : FirStringConcatenationCall(session, psi) { +class FirStringConcatenationCallImpl(psi: PsiElement?) : FirStringConcatenationCall(psi) { override fun replaceTypeRef(newTypeRef: FirTypeRef) {} - override var typeRef: FirTypeRef = FirImplicitStringTypeRef(session, psi) + override var typeRef: FirTypeRef = FirImplicitStringTypeRef(psi) override fun transformChildren(transformer: FirTransformer, data: D): FirElement { typeRef = typeRef.transformSingle(transformer, data) diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirThrowExpressionImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirThrowExpressionImpl.kt index ca5f2acb7d6..98e13ba5891 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirThrowExpressionImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirThrowExpressionImpl.kt @@ -7,7 +7,6 @@ package org.jetbrains.kotlin.fir.expressions.impl import com.intellij.psi.PsiElement import org.jetbrains.kotlin.fir.FirElement -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.expressions.FirExpression import org.jetbrains.kotlin.fir.expressions.FirThrowExpression import org.jetbrains.kotlin.fir.transformSingle @@ -16,10 +15,9 @@ import org.jetbrains.kotlin.fir.types.impl.FirImplicitNothingTypeRef import org.jetbrains.kotlin.fir.visitors.FirTransformer class FirThrowExpressionImpl( - session: FirSession, psi: PsiElement?, override var exception: FirExpression -) : FirThrowExpression(session, psi) { +) : FirThrowExpression(psi) { override fun replaceTypeRef(newTypeRef: FirTypeRef) {} override fun transformChildren(transformer: FirTransformer, data: D): FirElement { @@ -28,5 +26,5 @@ class FirThrowExpressionImpl( return super.transformChildren(transformer, data) } - override var typeRef: FirTypeRef = FirImplicitNothingTypeRef(session, psi) + override var typeRef: FirTypeRef = FirImplicitNothingTypeRef(psi) } \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirTryExpressionImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirTryExpressionImpl.kt index 4d19a137d52..4a8dab30b66 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirTryExpressionImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirTryExpressionImpl.kt @@ -7,7 +7,6 @@ package org.jetbrains.kotlin.fir.expressions.impl import com.intellij.psi.PsiElement 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.FirCatch import org.jetbrains.kotlin.fir.expressions.FirTryExpression @@ -16,11 +15,10 @@ import org.jetbrains.kotlin.fir.transformSingle import org.jetbrains.kotlin.fir.visitors.FirTransformer class FirTryExpressionImpl( - session: FirSession, psi: PsiElement?, override var tryBlock: FirBlock, override var finallyBlock: FirBlock? -) : FirTryExpression(session, psi) { +) : FirTryExpression(psi) { override val catches = mutableListOf() override fun transformChildren(transformer: FirTransformer, data: D): FirElement { diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirTypeOperatorCallImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirTypeOperatorCallImpl.kt index a67a2cd0e25..e7b1aa38315 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirTypeOperatorCallImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirTypeOperatorCallImpl.kt @@ -7,7 +7,6 @@ package org.jetbrains.kotlin.fir.expressions.impl import com.intellij.psi.PsiElement import org.jetbrains.kotlin.fir.FirElement -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.expressions.FirOperation import org.jetbrains.kotlin.fir.expressions.FirTypeOperatorCall import org.jetbrains.kotlin.fir.transformSingle @@ -15,11 +14,10 @@ import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.fir.visitors.FirTransformer class FirTypeOperatorCallImpl( - session: FirSession, psi: PsiElement?, operation: FirOperation, override var conversionTypeRef: FirTypeRef -) : FirTypeOperatorCall(session, psi, operation) { +) : FirTypeOperatorCall(psi, operation) { override fun transformChildren(transformer: FirTransformer, data: D): FirElement { conversionTypeRef = conversionTypeRef.transformSingle(transformer, data) return super.transformChildren(transformer, data) diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirUncheckedNotNullCastImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirUncheckedNotNullCastImpl.kt index 14fd1f5289d..83534239892 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirUncheckedNotNullCastImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirUncheckedNotNullCastImpl.kt @@ -6,15 +6,10 @@ package org.jetbrains.kotlin.fir.expressions.impl import com.intellij.psi.PsiElement -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.expressions.FirExpression import org.jetbrains.kotlin.fir.expressions.FirUncheckedNotNullCast -class FirUncheckedNotNullCastImpl( - session: FirSession, - psi: PsiElement?, - expression: FirExpression -) : FirUncheckedNotNullCast(session, psi) { +class FirUncheckedNotNullCastImpl(psi: PsiElement?, expression: FirExpression) : FirUncheckedNotNullCast(psi) { init { arguments += expression } diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirUnitExpression.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirUnitExpression.kt index 6dfee5b67f9..ef4bb5a7609 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirUnitExpression.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirUnitExpression.kt @@ -7,20 +7,16 @@ package org.jetbrains.kotlin.fir.expressions.impl import com.intellij.psi.PsiElement import org.jetbrains.kotlin.fir.FirElement -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.expressions.FirExpression import org.jetbrains.kotlin.fir.transformSingle import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.fir.types.impl.FirImplicitUnitTypeRef import org.jetbrains.kotlin.fir.visitors.FirTransformer -class FirUnitExpression( - session: FirSession, - psi: PsiElement? -) : FirExpression(session, psi) { +class FirUnitExpression(psi: PsiElement?) : FirExpression(psi) { override fun replaceTypeRef(newTypeRef: FirTypeRef) {} - override var typeRef: FirTypeRef = FirImplicitUnitTypeRef(session, psi) + override var typeRef: FirTypeRef = FirImplicitUnitTypeRef(psi) override fun transformChildren(transformer: FirTransformer, data: D): FirElement { typeRef = typeRef.transformSingle(transformer, data) diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirUnknownTypeCallWithArgumentList.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirUnknownTypeCallWithArgumentList.kt index 8d5957e1367..68937a7afa0 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirUnknownTypeCallWithArgumentList.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirUnknownTypeCallWithArgumentList.kt @@ -7,17 +7,15 @@ package org.jetbrains.kotlin.fir.expressions.impl import com.intellij.psi.PsiElement import org.jetbrains.kotlin.fir.FirElement -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.transformSingle import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.fir.types.impl.FirImplicitTypeRefImpl import org.jetbrains.kotlin.fir.visitors.FirTransformer abstract class FirUnknownTypeCallWithArgumentList( - session: FirSession, psi: PsiElement? -) : FirCallWithArgumentList(session, psi) { - override var typeRef: FirTypeRef = FirImplicitTypeRefImpl(session, null) +) : FirCallWithArgumentList(psi) { + override var typeRef: FirTypeRef = FirImplicitTypeRefImpl(null) override fun replaceTypeRef(newTypeRef: FirTypeRef) { typeRef = newTypeRef diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirUnknownTypeExpression.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirUnknownTypeExpression.kt index 53adab95bba..ac2de5054a2 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirUnknownTypeExpression.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirUnknownTypeExpression.kt @@ -7,7 +7,6 @@ package org.jetbrains.kotlin.fir.expressions.impl import com.intellij.psi.PsiElement import org.jetbrains.kotlin.fir.FirElement -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.expressions.FirExpression import org.jetbrains.kotlin.fir.transformSingle import org.jetbrains.kotlin.fir.types.FirTypeRef @@ -15,10 +14,9 @@ import org.jetbrains.kotlin.fir.types.impl.FirImplicitTypeRefImpl import org.jetbrains.kotlin.fir.visitors.FirTransformer abstract class FirUnknownTypeExpression( - session: FirSession, psi: PsiElement? -) : FirExpression(session, psi) { - final override var typeRef: FirTypeRef = FirImplicitTypeRefImpl(session, null) +) : FirExpression(psi) { + final override var typeRef: FirTypeRef = FirImplicitTypeRefImpl(null) final override fun replaceTypeRef(newTypeRef: FirTypeRef) { typeRef = newTypeRef diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirVariableAssignmentImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirVariableAssignmentImpl.kt index 18578570f9b..e7d77c97c6b 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirVariableAssignmentImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirVariableAssignmentImpl.kt @@ -6,15 +6,13 @@ package org.jetbrains.kotlin.fir.expressions.impl import com.intellij.psi.PsiElement -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.expressions.FirExpression import org.jetbrains.kotlin.fir.expressions.FirOperation import org.jetbrains.kotlin.fir.expressions.FirVariableAssignment class FirVariableAssignmentImpl( - session: FirSession, psi: PsiElement?, value: FirExpression, operation: FirOperation, safe: Boolean = false -) : FirAbstractAssignment(session, psi, value, operation, safe), FirVariableAssignment \ No newline at end of file +) : FirAbstractAssignment(psi, value, operation, safe), FirVariableAssignment \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirWhenBranchImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirWhenBranchImpl.kt index a2bee66faee..e5ed8cab6cb 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirWhenBranchImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirWhenBranchImpl.kt @@ -16,11 +16,10 @@ import org.jetbrains.kotlin.fir.transformSingle import org.jetbrains.kotlin.fir.visitors.FirTransformer class FirWhenBranchImpl( - session: FirSession, psi: PsiElement?, override var condition: FirExpression, override var result: FirBlock -) : FirAbstractElement(session, psi), FirWhenBranch { +) : FirAbstractElement(psi), FirWhenBranch { override fun transformChildren(transformer: FirTransformer, data: D): FirElement { condition = condition.transformSingle(transformer, data) result = result.transformSingle(transformer, data) diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirWhenExpressionImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirWhenExpressionImpl.kt index d0922e0942a..80253336831 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirWhenExpressionImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirWhenExpressionImpl.kt @@ -14,11 +14,10 @@ import org.jetbrains.kotlin.fir.expressions.FirWhenExpression import org.jetbrains.kotlin.fir.visitors.FirTransformer class FirWhenExpressionImpl( - session: FirSession, psiElement: PsiElement?, override var subject: FirExpression? = null, override var subjectVariable: FirVariable<*>? = null -) : FirWhenExpression(session, psiElement) { +) : FirWhenExpression(psiElement) { override val branches = mutableListOf() override fun transformChildren(transformer: FirTransformer, data: D): FirElement { diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirWhenSubjectExpressionImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirWhenSubjectExpressionImpl.kt index 57a0c5367f7..c88642dbbac 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirWhenSubjectExpressionImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirWhenSubjectExpressionImpl.kt @@ -6,12 +6,7 @@ package org.jetbrains.kotlin.fir.expressions.impl import com.intellij.psi.PsiElement -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.FirWhenSubject import org.jetbrains.kotlin.fir.expressions.FirWhenSubjectExpression -class FirWhenSubjectExpressionImpl( - session: FirSession, - psi: PsiElement?, - override val whenSubject: FirWhenSubject -) : FirWhenSubjectExpression(session, psi) \ No newline at end of file +class FirWhenSubjectExpressionImpl(psi: PsiElement?, override val whenSubject: FirWhenSubject) : FirWhenSubjectExpression(psi) \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirWhileLoopImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirWhileLoopImpl.kt index 5382f529f3d..64faa2d7c60 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirWhileLoopImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirWhileLoopImpl.kt @@ -6,12 +6,7 @@ package org.jetbrains.kotlin.fir.expressions.impl import com.intellij.psi.PsiElement -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.expressions.FirExpression import org.jetbrains.kotlin.fir.expressions.FirWhileLoop -class FirWhileLoopImpl( - session: FirSession, - psi: PsiElement?, - condition: FirExpression -) : FirAbstractLoop(session, psi, condition), FirWhileLoop \ No newline at end of file +class FirWhileLoopImpl(psi: PsiElement?, condition: FirExpression) : FirAbstractLoop(psi, condition), FirWhileLoop \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirWrappedDelegateExpressionImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirWrappedDelegateExpressionImpl.kt index b8b62fd1292..b222521f0fa 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirWrappedDelegateExpressionImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirWrappedDelegateExpressionImpl.kt @@ -7,17 +7,15 @@ package org.jetbrains.kotlin.fir.expressions.impl import com.intellij.psi.PsiElement import org.jetbrains.kotlin.fir.FirElement -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.expressions.FirExpression import org.jetbrains.kotlin.fir.expressions.FirWrappedDelegateExpression import org.jetbrains.kotlin.fir.transformSingle import org.jetbrains.kotlin.fir.visitors.FirTransformer class FirWrappedDelegateExpressionImpl( - session: FirSession, psi: PsiElement?, override var expression: FirExpression -) : FirWrappedDelegateExpression(session, psi) { +) : FirWrappedDelegateExpression(psi) { override lateinit var delegateProvider: FirExpression override fun transformChildren(transformer: FirTransformer, data: D): FirElement { diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/labels/FirLabelImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/labels/FirLabelImpl.kt index 8160318d685..47f41c6a16d 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/labels/FirLabelImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/labels/FirLabelImpl.kt @@ -8,10 +8,8 @@ package org.jetbrains.kotlin.fir.labels import com.intellij.psi.PsiElement import org.jetbrains.kotlin.fir.FirAbstractElement import org.jetbrains.kotlin.fir.FirLabel -import org.jetbrains.kotlin.fir.FirSession class FirLabelImpl( - session: FirSession, psi: PsiElement?, override val name: String -) : FirAbstractElement(session, psi), FirLabel \ No newline at end of file +) : FirAbstractElement(psi), FirLabel \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/references/FirBackingFieldReferenceImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/references/FirBackingFieldReferenceImpl.kt index 4322ab1fd3a..f31f37d3b63 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/references/FirBackingFieldReferenceImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/references/FirBackingFieldReferenceImpl.kt @@ -8,11 +8,9 @@ package org.jetbrains.kotlin.fir.references import com.intellij.psi.PsiElement import org.jetbrains.kotlin.fir.FirAbstractElement import org.jetbrains.kotlin.fir.FirBackingFieldReference -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.symbols.impl.FirBackingFieldSymbol class FirBackingFieldReferenceImpl( - session: FirSession, psi: PsiElement?, override val coneSymbol: FirBackingFieldSymbol -) : FirAbstractElement(session, psi), FirBackingFieldReference \ No newline at end of file +) : FirAbstractElement(psi), FirBackingFieldReference \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/references/FirDelegateFieldReferenceImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/references/FirDelegateFieldReferenceImpl.kt index 57a3c2163d2..ffefac60b31 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/references/FirDelegateFieldReferenceImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/references/FirDelegateFieldReferenceImpl.kt @@ -8,11 +8,9 @@ package org.jetbrains.kotlin.fir.references import com.intellij.psi.PsiElement import org.jetbrains.kotlin.fir.FirAbstractElement import org.jetbrains.kotlin.fir.FirDelegateFieldReference -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.symbols.impl.FirDelegateFieldSymbol class FirDelegateFieldReferenceImpl( - session: FirSession, psi: PsiElement?, override val coneSymbol: FirDelegateFieldSymbol<*> -) : FirAbstractElement(session, psi), FirDelegateFieldReference \ No newline at end of file +) : FirAbstractElement(psi), FirDelegateFieldReference \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/references/FirErrorNamedReference.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/references/FirErrorNamedReference.kt index 43561e9fe73..f719f5068ea 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/references/FirErrorNamedReference.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/references/FirErrorNamedReference.kt @@ -8,12 +8,10 @@ package org.jetbrains.kotlin.fir.references import com.intellij.psi.PsiElement import org.jetbrains.kotlin.fir.FirAbstractElement import org.jetbrains.kotlin.fir.FirNamedReference -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.name.Name class FirErrorNamedReference( - session: FirSession, psi: PsiElement?, val errorReason: String, override val name: Name = Name.special("<$errorReason>") -) : FirAbstractElement(session, psi), FirNamedReference \ No newline at end of file +) : FirAbstractElement(psi), FirNamedReference \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/references/FirExplicitSuperReference.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/references/FirExplicitSuperReference.kt index c4ba0296041..c4a918c863f 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/references/FirExplicitSuperReference.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/references/FirExplicitSuperReference.kt @@ -11,10 +11,9 @@ import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.fir.visitors.FirTransformer class FirExplicitSuperReference( - session: FirSession, psi: PsiElement?, override var superTypeRef: FirTypeRef -) : FirAbstractElement(session, psi), FirSuperReference { +) : FirAbstractElement(psi), FirSuperReference { override fun replaceSuperTypeRef(newSuperTypeRef: FirTypeRef) { superTypeRef = newSuperTypeRef } diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/references/FirExplicitThisReference.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/references/FirExplicitThisReference.kt index b5c2614bd64..7578ba0cbb7 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/references/FirExplicitThisReference.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/references/FirExplicitThisReference.kt @@ -7,11 +7,6 @@ package org.jetbrains.kotlin.fir.references import com.intellij.psi.PsiElement import org.jetbrains.kotlin.fir.FirAbstractElement -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.FirThisReference -class FirExplicitThisReference( - session: FirSession, - psi: PsiElement?, - override val labelName: String? -) : FirAbstractElement(session, psi), FirThisReference \ No newline at end of file +class FirExplicitThisReference(psi: PsiElement?, override val labelName: String?) : FirAbstractElement(psi), FirThisReference \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/references/FirPropertyFromParameterCallableReference.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/references/FirPropertyFromParameterCallableReference.kt index a88f0ca8f9d..ffd0b004116 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/references/FirPropertyFromParameterCallableReference.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/references/FirPropertyFromParameterCallableReference.kt @@ -8,13 +8,11 @@ package org.jetbrains.kotlin.fir.references import com.intellij.psi.PsiElement import org.jetbrains.kotlin.fir.FirAbstractElement import org.jetbrains.kotlin.fir.FirResolvedCallableReference -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol import org.jetbrains.kotlin.name.Name class FirPropertyFromParameterCallableReference( - session: FirSession, psi: PsiElement?, override val name: Name, override val coneSymbol: FirVariableSymbol<*> -) : FirAbstractElement(session, psi), FirResolvedCallableReference \ No newline at end of file +) : FirAbstractElement(psi), FirResolvedCallableReference \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/references/FirResolvedCallableReferenceImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/references/FirResolvedCallableReferenceImpl.kt index b6f8eb587d6..2e34282a32e 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/references/FirResolvedCallableReferenceImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/references/FirResolvedCallableReferenceImpl.kt @@ -8,13 +8,11 @@ package org.jetbrains.kotlin.fir.references import com.intellij.psi.PsiElement import org.jetbrains.kotlin.fir.FirAbstractElement import org.jetbrains.kotlin.fir.FirResolvedCallableReference -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.symbols.ConeSymbol import org.jetbrains.kotlin.name.Name class FirResolvedCallableReferenceImpl( - session: FirSession, psi: PsiElement?, override val name: Name, override val coneSymbol: ConeSymbol -) : FirAbstractElement(session, psi), FirResolvedCallableReference \ No newline at end of file +) : FirAbstractElement(psi), FirResolvedCallableReference \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/references/FirSimpleNamedReference.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/references/FirSimpleNamedReference.kt index 6f349afbf61..5e53f03ce94 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/references/FirSimpleNamedReference.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/references/FirSimpleNamedReference.kt @@ -8,11 +8,6 @@ package org.jetbrains.kotlin.fir.references import com.intellij.psi.PsiElement import org.jetbrains.kotlin.fir.FirAbstractElement import org.jetbrains.kotlin.fir.FirNamedReference -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.name.Name -open class FirSimpleNamedReference( - session: FirSession, - psi: PsiElement?, - override val name: Name -) : FirAbstractElement(session, psi), FirNamedReference \ No newline at end of file +open class FirSimpleNamedReference(psi: PsiElement?, override val name: Name) : FirAbstractElement(psi), FirNamedReference \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirAbstractAnnotatedTypeRef.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirAbstractAnnotatedTypeRef.kt index 05d3d5c23e7..4fb6e5b99ca 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirAbstractAnnotatedTypeRef.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirAbstractAnnotatedTypeRef.kt @@ -8,17 +8,15 @@ package org.jetbrains.kotlin.fir.types.impl import com.intellij.psi.PsiElement import org.jetbrains.kotlin.fir.FirAbstractElement import org.jetbrains.kotlin.fir.FirElement -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.transformInplace import org.jetbrains.kotlin.fir.types.FirTypeRefWithNullability import org.jetbrains.kotlin.fir.visitors.FirTransformer abstract class FirAbstractAnnotatedTypeRef( - session: FirSession, psi: PsiElement?, final override val isMarkedNullable: Boolean -) : FirTypeRefWithNullability, FirAbstractElement(session, psi) { +) : FirTypeRefWithNullability, FirAbstractElement(psi) { override val annotations = mutableListOf() override fun transformChildren(transformer: FirTransformer, data: D): FirElement { diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirDelegatedTypeRefImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirDelegatedTypeRefImpl.kt index f94603cedb9..a1965c6e823 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirDelegatedTypeRefImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirDelegatedTypeRefImpl.kt @@ -7,7 +7,6 @@ package org.jetbrains.kotlin.fir.types.impl import org.jetbrains.kotlin.fir.FirAbstractElement 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.FirExpression import org.jetbrains.kotlin.fir.transformSingle @@ -16,10 +15,9 @@ import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.fir.visitors.FirTransformer class FirDelegatedTypeRefImpl( - session: FirSession, override var typeRef: FirTypeRef, override var delegate: FirExpression? -) : FirAbstractElement(session, typeRef.psi), FirDelegatedTypeRef { +) : FirAbstractElement(typeRef.psi), FirDelegatedTypeRef { override val annotations: List get() = typeRef.annotations diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirDynamicTypeRefImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirDynamicTypeRefImpl.kt index 14e357fdee6..708cbd7c198 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirDynamicTypeRefImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirDynamicTypeRefImpl.kt @@ -6,11 +6,9 @@ package org.jetbrains.kotlin.fir.types.impl import com.intellij.psi.PsiElement -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.types.FirDynamicTypeRef class FirDynamicTypeRefImpl( - session: FirSession, psi: PsiElement?, isNullable: Boolean -) : FirAbstractAnnotatedTypeRef(session, psi, isNullable), FirDynamicTypeRef \ No newline at end of file +) : FirAbstractAnnotatedTypeRef(psi, isNullable), FirDynamicTypeRef \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirErrorTypeRefImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirErrorTypeRefImpl.kt index 22d117f531c..f7763fd5a44 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirErrorTypeRefImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirErrorTypeRefImpl.kt @@ -6,17 +6,15 @@ package org.jetbrains.kotlin.fir.types.impl import com.intellij.psi.PsiElement -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.types.ConeKotlinErrorType import org.jetbrains.kotlin.fir.types.ConeKotlinType import org.jetbrains.kotlin.fir.types.FirErrorTypeRef import org.jetbrains.kotlin.fir.visitors.FirVisitor class FirErrorTypeRefImpl( - session: FirSession, psi: PsiElement?, override val reason: String -) : FirAbstractAnnotatedTypeRef(session, psi, false), FirErrorTypeRef { +) : FirAbstractAnnotatedTypeRef(psi, false), FirErrorTypeRef { override val type: ConeKotlinType = ConeKotlinErrorType(reason) override fun accept(visitor: FirVisitor, data: D): R { diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirFunctionTypeRefImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirFunctionTypeRefImpl.kt index 64610b4dac1..dca53d43286 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirFunctionTypeRefImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirFunctionTypeRefImpl.kt @@ -7,7 +7,6 @@ package org.jetbrains.kotlin.fir.types.impl import com.intellij.psi.PsiElement import org.jetbrains.kotlin.fir.FirElement -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.declarations.FirValueParameter import org.jetbrains.kotlin.fir.transformInplace import org.jetbrains.kotlin.fir.transformSingle @@ -16,12 +15,11 @@ import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.fir.visitors.FirTransformer class FirFunctionTypeRefImpl( - session: FirSession, psi: PsiElement?, isNullable: Boolean, override var receiverTypeRef: FirTypeRef?, override var returnTypeRef: FirTypeRef -) : FirAbstractAnnotatedTypeRef(session, psi, isNullable), FirFunctionTypeRef { +) : FirAbstractAnnotatedTypeRef(psi, isNullable), FirFunctionTypeRef { override val valueParameters = mutableListOf() override fun transformChildren(transformer: FirTransformer, data: D): FirElement { diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirImplicitBuiltinTypeRef.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirImplicitBuiltinTypeRef.kt index a9b6200e370..d4074915897 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirImplicitBuiltinTypeRef.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirImplicitBuiltinTypeRef.kt @@ -7,7 +7,6 @@ package org.jetbrains.kotlin.fir.types.impl import com.intellij.psi.PsiElement import org.jetbrains.kotlin.fir.FirAbstractElement -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTagImpl import org.jetbrains.kotlin.fir.symbols.StandardClassIds @@ -17,12 +16,11 @@ import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef import org.jetbrains.kotlin.name.ClassId sealed class FirImplicitBuiltinTypeRef( - session: FirSession, psi: PsiElement?, val id: ClassId, typeArguments: Array = emptyArray(), isNullable: Boolean = false -) : FirResolvedTypeRef, FirAbstractElement(session, psi) { +) : FirResolvedTypeRef, FirAbstractElement(psi) { override val annotations: List get() = emptyList() @@ -30,47 +28,38 @@ sealed class FirImplicitBuiltinTypeRef( } class FirImplicitUnitTypeRef( - session: FirSession, psi: PsiElement? -) : FirImplicitBuiltinTypeRef(session, psi, StandardClassIds.Unit) +) : FirImplicitBuiltinTypeRef(psi, StandardClassIds.Unit) class FirImplicitAnyTypeRef( - session: FirSession, psi: PsiElement? -) : FirImplicitBuiltinTypeRef(session, psi, StandardClassIds.Any) +) : FirImplicitBuiltinTypeRef(psi, StandardClassIds.Any) class FirImplicitNullableAnyTypeRef( - session: FirSession, psi: PsiElement? -) : FirImplicitBuiltinTypeRef(session, psi, StandardClassIds.Any, isNullable = true) +) : FirImplicitBuiltinTypeRef(psi, StandardClassIds.Any, isNullable = true) class FirImplicitEnumTypeRef( - session: FirSession, psi: PsiElement? -) : FirImplicitBuiltinTypeRef(session, psi, StandardClassIds.Enum) +) : FirImplicitBuiltinTypeRef(psi, StandardClassIds.Enum) class FirImplicitAnnotationTypeRef( - session: FirSession, psi: PsiElement? -) : FirImplicitBuiltinTypeRef(session, psi, StandardClassIds.Annotation) +) : FirImplicitBuiltinTypeRef(psi, StandardClassIds.Annotation) class FirImplicitBooleanTypeRef( - session: FirSession, psi: PsiElement? -) : FirImplicitBuiltinTypeRef(session, psi, StandardClassIds.Boolean) +) : FirImplicitBuiltinTypeRef(psi, StandardClassIds.Boolean) class FirImplicitNothingTypeRef( - session: FirSession, psi: PsiElement? -) : FirImplicitBuiltinTypeRef(session, psi, StandardClassIds.Nothing) +) : FirImplicitBuiltinTypeRef(psi, StandardClassIds.Nothing) class FirImplicitStringTypeRef( - session: FirSession, psi: PsiElement? -) : FirImplicitBuiltinTypeRef(session, psi, StandardClassIds.String) +) : FirImplicitBuiltinTypeRef(psi, StandardClassIds.String) class FirImplicitKPropertyTypeRef( - session: FirSession, psi: PsiElement?, typeArgument: ConeKotlinTypeProjection -) : FirImplicitBuiltinTypeRef(session, psi, StandardClassIds.KProperty, arrayOf(typeArgument)) \ No newline at end of file +) : FirImplicitBuiltinTypeRef(psi, StandardClassIds.KProperty, arrayOf(typeArgument)) \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirImplicitTypeRefImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirImplicitTypeRefImpl.kt index da2825b6734..d021104efc4 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirImplicitTypeRefImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirImplicitTypeRefImpl.kt @@ -8,14 +8,12 @@ package org.jetbrains.kotlin.fir.types.impl import com.intellij.psi.PsiElement import org.jetbrains.kotlin.fir.FirAbstractElement import org.jetbrains.kotlin.fir.FirPureAbstractElement -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.types.FirImplicitTypeRef class FirImplicitTypeRefImpl( - session: FirSession, psi: PsiElement? -) : FirImplicitTypeRef, FirAbstractElement(session, psi) { +) : FirImplicitTypeRef, FirAbstractElement(psi) { override val annotations: List get() = emptyList() } @@ -23,8 +21,6 @@ class FirImplicitTypeRefImpl( object FirComputingImplicitTypeRef : FirImplicitTypeRef, FirPureAbstractElement() { override val psi: PsiElement? get() = null - override val session: FirSession - get() = error("Session independent") override val annotations: List get() = emptyList() diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirResolvedFunctionTypeRefImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirResolvedFunctionTypeRefImpl.kt index 223850375dd..a14ba56a0ca 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirResolvedFunctionTypeRefImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirResolvedFunctionTypeRefImpl.kt @@ -16,14 +16,13 @@ import org.jetbrains.kotlin.fir.visitors.FirTransformer class FirResolvedFunctionTypeRefImpl( psi: PsiElement?, - session: FirSession, override val isMarkedNullable: Boolean, override val annotations: MutableList, override var receiverTypeRef: FirTypeRef?, override val valueParameters: MutableList, override var returnTypeRef: FirTypeRef, override val type: ConeKotlinType -) : FirResolvedFunctionTypeRef, FirAbstractElement(session, psi) { +) : FirResolvedFunctionTypeRef, FirAbstractElement(psi) { override fun transformChildren(transformer: FirTransformer, data: D): FirElement { receiverTypeRef = receiverTypeRef?.transformSingle(transformer, data) diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirResolvedTypeRefImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirResolvedTypeRefImpl.kt index cc4741de9fb..c100e706407 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirResolvedTypeRefImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirResolvedTypeRefImpl.kt @@ -7,14 +7,12 @@ package org.jetbrains.kotlin.fir.types.impl import com.intellij.psi.PsiElement import org.jetbrains.kotlin.fir.FirAbstractElement -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.types.ConeKotlinType import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef class FirResolvedTypeRefImpl( - session: FirSession, psi: PsiElement?, override val type: ConeKotlinType, override val annotations: List = emptyList() -) : FirResolvedTypeRef, FirAbstractElement(session, psi) \ No newline at end of file +) : FirResolvedTypeRef, FirAbstractElement(psi) \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirStarProjectionImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirStarProjectionImpl.kt index 02b9a807a2e..8d21e9ad6a7 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirStarProjectionImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirStarProjectionImpl.kt @@ -7,10 +7,6 @@ package org.jetbrains.kotlin.fir.types.impl import com.intellij.psi.PsiElement import org.jetbrains.kotlin.fir.FirAbstractElement -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.types.FirStarProjection -class FirStarProjectionImpl( - session: FirSession, - psi: PsiElement? -) : FirStarProjection, FirAbstractElement(session, psi) \ No newline at end of file +class FirStarProjectionImpl(psi: PsiElement?) : FirStarProjection, FirAbstractElement(psi) \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirTypePlaceholderProjection.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirTypePlaceholderProjection.kt index c11d90c63f6..7fd3d1cd435 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirTypePlaceholderProjection.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirTypePlaceholderProjection.kt @@ -6,12 +6,9 @@ package org.jetbrains.kotlin.fir.types.impl import com.intellij.psi.PsiElement -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.types.FirTypeProjection object FirTypePlaceholderProjection : FirTypeProjection { override val psi: PsiElement? get() = null // TODO - override val session: FirSession - get() = error("ahahahhahah") } \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirTypeProjectionWithVarianceImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirTypeProjectionWithVarianceImpl.kt index c3c0ad56993..23ef03d0186 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirTypeProjectionWithVarianceImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirTypeProjectionWithVarianceImpl.kt @@ -8,7 +8,6 @@ package org.jetbrains.kotlin.fir.types.impl import com.intellij.psi.PsiElement import org.jetbrains.kotlin.fir.FirAbstractElement import org.jetbrains.kotlin.fir.FirElement -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.transformSingle import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.fir.types.FirTypeProjectionWithVariance @@ -16,11 +15,10 @@ import org.jetbrains.kotlin.fir.visitors.FirTransformer import org.jetbrains.kotlin.types.Variance class FirTypeProjectionWithVarianceImpl( - session: FirSession, psi: PsiElement?, override val variance: Variance, override var typeRef: FirTypeRef -) : FirTypeProjectionWithVariance, FirAbstractElement(session, psi) { +) : FirTypeProjectionWithVariance, FirAbstractElement(psi) { override fun transformChildren(transformer: FirTransformer, data: D): FirElement { typeRef = typeRef.transformSingle(transformer, data) diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirUserTypeRefImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirUserTypeRefImpl.kt index 53c9e10575d..e5d51b2aea9 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirUserTypeRefImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirUserTypeRefImpl.kt @@ -7,7 +7,6 @@ package org.jetbrains.kotlin.fir.types.impl import com.intellij.psi.PsiElement import org.jetbrains.kotlin.fir.FirElement -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.transformInplace import org.jetbrains.kotlin.fir.types.FirQualifierPart import org.jetbrains.kotlin.fir.types.FirTypeProjection @@ -15,10 +14,9 @@ import org.jetbrains.kotlin.fir.types.FirUserTypeRef import org.jetbrains.kotlin.fir.visitors.FirTransformer open class FirUserTypeRefImpl( - session: FirSession, psi: PsiElement?, isMarkedNullable: Boolean -) : FirAbstractAnnotatedTypeRef(session, psi, isMarkedNullable), FirUserTypeRef { +) : FirAbstractAnnotatedTypeRef(psi, isMarkedNullable), FirUserTypeRef { override val qualifier = mutableListOf() override fun transformChildren(transformer: FirTransformer, data: D): FirElement { diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/fir/FirResolveBench.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/fir/FirResolveBench.kt index e95c4b0a84d..8d6cf7c21f4 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/fir/FirResolveBench.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/fir/FirResolveBench.kt @@ -24,7 +24,7 @@ import kotlin.system.measureNanoTime fun checkFirProvidersConsistency(firFiles: List) { - for ((session, files) in firFiles.groupBy { it.session }) { + for ((session, files) in firFiles.groupBy { it.fileSession }) { val provider = session.service() as FirProviderImpl provider.ensureConsistent(files) }