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

K2: Remove a bunch of unused declarations

Browse Source
This commit is contained in:
Denis.Zharkov
2023-06-26 16:09:31 +03:00
committed by Space Team
parent 1705d5f704
commit e98890cece
45 changed files with 33 additions and 437 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/diagnostics/FirDiagnosticsList.kt
-6
View File
@@ -1592,12 +1592,6 @@ private inline fun <reified P : PsiElement> AbstractDiagnosticGroup.exposedVisib
return error<P>(positioningStrategy, exposedVisibilityDiagnosticInit)
}
private inline fun <reified P : PsiElement> AbstractDiagnosticGroup.exposedVisibilityWarning(
positioningStrategy: PositioningStrategy = PositioningStrategy.DEFAULT
): PropertyDelegateProvider<Any?, ReadOnlyProperty<AbstractDiagnosticGroup, RegularDiagnosticData>> {
return warning<P>(positioningStrategy, exposedVisibilityDiagnosticInit)
}
private inline fun <reified P : PsiElement> AbstractDiagnosticGroup.exposedVisibilityDeprecationError(
languageFeature: LanguageFeature,
positioningStrategy: PositioningStrategy = PositioningStrategy.DEFAULT
compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/diagnostics/model/RegularDiagnosticData.kt
-3
View File
@@ -81,13 +81,10 @@ enum class PositioningStrategy(private val strategy: String? = null) {
RETURN_WITH_LABEL,
PROPERTY_INITIALIZER,
WHOLE_ELEMENT,
INT_LITERAL_OUT_OF_RANGE,
FLOAT_LITERAL_OUT_OF_RANGE,
LONG_LITERAL_SUFFIX,
REIFIED_MODIFIER,
TYPE_PARAMETERS_LIST,
FUN_MODIFIER,
SUSPEND_MODIFIER,
FUN_INTERFACE,
NAME_IDENTIFIER,
QUESTION_MARK_BY_TYPE,
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/cfa/util/DeclaredVariableCollector.kt
-4
View File
@@ -34,10 +34,6 @@ class DeclaredVariableCollector {
declaredVariablesPerElement.removeKey(statement)
}
fun resetState() {
declaredVariablesPerElement.clear()
}
// FirStatement -- closest statement (loop/lambda/local declaration) which may contain reassignments
private val visitor = object : FirVisitor<Unit, FirStatement?>() {
override fun visitElement(element: FirElement, data: FirStatement?) {
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirHelpers.kt
-10
View File
@@ -190,16 +190,6 @@ fun CheckerContext.findClosestClassOrObject(): FirClass? {
return null
}
/**
* Returns the list of functions that overridden by given
*/
fun FirSimpleFunction.overriddenFunctions(
containingClass: FirClassSymbol<*>,
context: CheckerContext,
): List<FirFunctionSymbol<*>> {
return symbol.overriddenFunctions(containingClass, context)
}
fun FirNamedFunctionSymbol.overriddenFunctions(
containingClass: FirClassSymbol<*>,
context: CheckerContext,
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/SourceHelpers.kt
-9
View File
@@ -5,20 +5,11 @@
package org.jetbrains.kotlin.fir.analysis.checkers
import com.intellij.lang.LighterASTNode
import com.intellij.openapi.util.Ref
import com.intellij.util.diff.FlyweightCapableTreeStructure
import org.jetbrains.kotlin.descriptors.Visibilities
import org.jetbrains.kotlin.descriptors.Visibility
import org.jetbrains.kotlin.lexer.KtModifierKeywordToken
import org.jetbrains.kotlin.lexer.KtTokens
import org.jetbrains.kotlin.psi.KtModifierList
import org.jetbrains.kotlin.psi.psiUtil.visibilityModifierType
/**
* Returns the visibility by given KtModifierList
*/
fun KtModifierList?.getVisibility() = this?.visibilityModifierType()?.toVisibilityOrNull()
/**
* Returns Visibility by token or null
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/SourceNavigator.kt
+1 -3
View File
@@ -11,9 +11,9 @@ import com.intellij.psi.PsiElement
import com.intellij.psi.PsiNameIdentifierOwner
import com.intellij.psi.impl.source.tree.LeafPsiElement
import org.jetbrains.kotlin.*
import org.jetbrains.kotlin.fir.FirElement
import org.jetbrains.kotlin.diagnostics.getAncestors
import org.jetbrains.kotlin.diagnostics.nameIdentifier
import org.jetbrains.kotlin.fir.FirElement
import org.jetbrains.kotlin.fir.declarations.FirDeclaration
import org.jetbrains.kotlin.fir.symbols.impl.FirValueParameterSymbol
import org.jetbrains.kotlin.fir.types.FirTypeRef
@@ -54,8 +54,6 @@ interface SourceNavigator {
}
inline fun <R> FirElement.withNavigator(block: SourceNavigator.() -> R): R = with(forSource(this.source), block)
inline fun <R> KtSourceElement.withNavigator(block: SourceNavigator.() -> R): R = with(forSource(this), block)
}
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/declarationUtils.kt
+4 -4
View File
@@ -14,8 +14,11 @@ import org.jetbrains.kotlin.fir.declarations.*
import org.jetbrains.kotlin.fir.declarations.utils.*
import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
import org.jetbrains.kotlin.fir.symbols.impl.*
import org.jetbrains.kotlin.fir.types.*
import org.jetbrains.kotlin.fir.types.FirTypeRef
import org.jetbrains.kotlin.fir.types.coneType
import org.jetbrains.kotlin.fir.types.impl.FirImplicitUnitTypeRef
import org.jetbrains.kotlin.fir.types.isNullable
import org.jetbrains.kotlin.fir.types.typeContext
internal fun isInsideExpectClass(containingClass: FirClass, context: CheckerContext): Boolean {
return isInsideSpecificClass(containingClass, context) { klass -> klass is FirRegularClass && klass.isExpect }
@@ -90,9 +93,6 @@ internal val FirBasedSymbol<*>.isLocalMember: Boolean
else -> false
}
internal val FirCallableDeclaration.isExtensionMember: Boolean
get() = symbol.isExtensionMember
internal val FirCallableSymbol<*>.isExtensionMember: Boolean
get() = resolvedReceiverTypeRef != null && dispatchReceiverType != null
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirBreakOrContinueJumpsAcrossFunctionBoundaryChecker.kt
-4
View File
@@ -121,8 +121,4 @@ object FirBreakOrContinueJumpsAcrossFunctionBoundaryChecker : FirLoopJumpChecker
findPathAndCheck(expression.target.labeledElement.block)
}
private fun FirExpression.tryInline(): FirExpression {
val anonymousFunctionExpression = (((this as? FirLambdaArgumentExpression)?.expression) ?: this) as? FirAnonymousFunctionExpression
return anonymousFunctionExpression?.anonymousFunction?.body ?: this
}
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirDiagnosticRenderers.kt
-9
View File
@@ -174,13 +174,4 @@ object FirDiagnosticRenderers {
}
val FUNCTIONAL_TYPE_KINDS = KtDiagnosticRenderers.COLLECTION(FUNCTIONAL_TYPE_KIND)
@Suppress("FunctionName")
fun <T> COLLECTION(renderer: ContextIndependentParameterRenderer<T>): ContextIndependentParameterRenderer<Collection<T>> {
return Renderer { list ->
list.joinToString(prefix = "[", postfix = "]", separator = ", ", limit = 3, truncated = "...") {
renderer.render(it)
}
}
}
}
compiler/fir/cones/src/org/jetbrains/kotlin/fir/types/CompilerConeAttributes.kt
-7
View File
@@ -131,13 +131,6 @@ val ConeAttributes.enhancedNullability: CompilerConeAttributes.EnhancedNullabili
val ConeAttributes.extensionFunctionType: CompilerConeAttributes.ExtensionFunctionType? by ConeAttributes.attributeAccessor<CompilerConeAttributes.ExtensionFunctionType>()
private val ConeAttributes.contextFunctionTypeParams: CompilerConeAttributes.ContextFunctionTypeParams? by ConeAttributes.attributeAccessor<CompilerConeAttributes.ContextFunctionTypeParams>()
val ConeAttributes.unsafeVarianceType: CompilerConeAttributes.UnsafeVariance? by ConeAttributes.attributeAccessor<CompilerConeAttributes.UnsafeVariance>()
// ------------------------------------------------------------------
val ConeAttributes.hasEnhancedNullability: Boolean
get() = enhancedNullability != null
// ------------------------------------------------------------------
val ConeKotlinType.hasEnhancedNullability: Boolean
compiler/fir/cones/src/org/jetbrains/kotlin/fir/types/ConeBuiltinTypeUtils.kt
-4
View File
@@ -58,10 +58,6 @@ val ConeKotlinType.isPrimitiveArray: Boolean
val ConeKotlinType.isUnsignedTypeOrNullableUnsignedType: Boolean get() = isAnyOfBuiltinType(StandardClassIds.unsignedTypes)
val ConeKotlinType.isUnsignedType: Boolean get() = isUnsignedTypeOrNullableUnsignedType && nullability == ConeNullability.NOT_NULL
val ConeKotlinType.isIntegerTypeOrNullableIntegerTypeOfAnySize: Boolean get() = isAnyOfBuiltinType(builtinIntegerTypes)
private val builtinIntegerTypes = setOf(StandardClassIds.Int, StandardClassIds.Byte, StandardClassIds.Long, StandardClassIds.Short)
private fun ConeKotlinType.isBuiltinType(classId: ClassId, isNullable: Boolean?): Boolean {
if (this !is ConeClassLikeType) return false
return lookupTag.classId == classId && (isNullable == null || type.isNullable == isNullable)
compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/FirModuleInfoBasedModuleData.kt
-45
View File
@@ -1,45 +0,0 @@
/*
* Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
* Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
*/
package org.jetbrains.kotlin.fir.session
import org.jetbrains.kotlin.analyzer.ModuleInfo
import org.jetbrains.kotlin.fir.FirModuleData
import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.platform.TargetPlatform
import org.jetbrains.kotlin.resolve.PlatformDependentAnalyzerServices
class FirModuleInfoBasedModuleData(val moduleInfo: ModuleInfo) : FirModuleData() {
override val name: Name
get() = moduleInfo.name
override val dependencies: List<FirModuleData> by lazy {
moduleInfo.dependencies()
.filterNot { it == moduleInfo }
.map { FirModuleInfoBasedModuleData(it) }
}
override val dependsOnDependencies: List<FirModuleData> = moduleInfo.expectedBy
.filterNot { it == moduleInfo }
.map { FirModuleInfoBasedModuleData(it) }
override val friendDependencies: List<FirModuleData> = moduleInfo.modulesWhoseInternalsAreVisible()
.filterNot { it == moduleInfo }
.map { FirModuleInfoBasedModuleData(it) }
override val platform: TargetPlatform
get() = moduleInfo.platform
override val analyzerServices: PlatformDependentAnalyzerServices
get() = moduleInfo.analyzerServices
override fun equals(other: Any?): Boolean {
if (other !is FirModuleInfoBasedModuleData) return false
return moduleInfo == other.moduleInfo
}
override fun hashCode(): Int {
return moduleInfo.hashCode()
}
}
compiler/fir/fir-deserialization/src/org/jetbrains/kotlin/fir/deserialization/ModuleDataProvider.kt
-8
View File
@@ -60,11 +60,3 @@ class MultipleModuleDataProvider(private val moduleDataWithFilters: Map<FirModul
}
}
class EmptyModuleDataProvider(
override val platform: TargetPlatform,
override val analyzerServices: PlatformDependentAnalyzerServices
) : ModuleDataProvider() {
override val allModuleData: Collection<FirModuleData> get() = emptyList()
override fun getModuleData(path: Path?): FirModuleData? = null
}
compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/FirElementSerializer.kt
+5 -16
View File
@@ -32,11 +32,14 @@ import org.jetbrains.kotlin.fir.expressions.builder.buildConstExpression
import org.jetbrains.kotlin.fir.expressions.impl.FirEmptyAnnotationArgumentMapping
import org.jetbrains.kotlin.fir.extensions.extensionService
import org.jetbrains.kotlin.fir.extensions.typeAttributeExtensions
import org.jetbrains.kotlin.fir.resolve.*
import org.jetbrains.kotlin.fir.resolve.ScopeSession
import org.jetbrains.kotlin.fir.resolve.fullyExpandedType
import org.jetbrains.kotlin.fir.resolve.providers.symbolProvider
import org.jetbrains.kotlin.fir.resolve.toSymbol
import org.jetbrains.kotlin.fir.scopes.*
import org.jetbrains.kotlin.fir.scopes.impl.nestedClassifierScope
import org.jetbrains.kotlin.fir.serialization.constant.*
import org.jetbrains.kotlin.fir.serialization.constant.hasConstantValue
import org.jetbrains.kotlin.fir.serialization.constant.toConstantValue
import org.jetbrains.kotlin.fir.symbols.impl.*
import org.jetbrains.kotlin.fir.types.*
import org.jetbrains.kotlin.fir.types.builder.buildResolvedTypeRef
@@ -1100,9 +1103,6 @@ class FirElementSerializer private constructor(
return writeLanguageVersionRequirement(languageFeature, this)
}
private fun MutableVersionRequirementTable.writeCompilerVersionRequirement(major: Int, minor: Int, patch: Int): Int =
writeCompilerVersionRequirement(major, minor, patch, this)
private fun MutableVersionRequirementTable.writeVersionRequirementDependingOnCoroutinesVersion(): Int =
writeVersionRequirement(LanguageFeature.ReleaseCoroutines)
@@ -1273,17 +1273,6 @@ class FirElementSerializer private constructor(
)
}
fun writeCompilerVersionRequirement(
major: Int,
minor: Int,
patch: Int,
versionRequirementTable: MutableVersionRequirementTable
): Int = writeVersionRequirement(
major, minor, patch,
ProtoBuf.VersionRequirement.VersionKind.COMPILER_VERSION,
versionRequirementTable
)
fun writeVersionRequirement(
major: Int,
minor: Int,
compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/constant/ConstantValueUtils.kt
-18
View File
@@ -11,13 +11,10 @@ import org.jetbrains.kotlin.constant.ConstantValue
import org.jetbrains.kotlin.constant.ErrorValue
import org.jetbrains.kotlin.constant.KClassValue
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.declarations.FirRegularClass
import org.jetbrains.kotlin.fir.declarations.FirValueParameter
import org.jetbrains.kotlin.fir.expressions.FirExpression
import org.jetbrains.kotlin.fir.languageVersionSettings
import org.jetbrains.kotlin.fir.render
import org.jetbrains.kotlin.fir.resolve.defaultType
import org.jetbrains.kotlin.fir.resolve.providers.symbolProvider
import org.jetbrains.kotlin.fir.types.*
import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.utils.addToStdlib.runIf
@@ -53,21 +50,6 @@ inline fun <reified T : ConeKotlinType> KClassValue.Value.LocalClass.coneType():
return this.type as T
}
internal fun KClassValue.getArgumentType(session: FirSession): ConeKotlinType? {
when (val castedValue = value) {
is KClassValue.Value.LocalClass -> return castedValue.type as ConeKotlinType
is KClassValue.Value.NormalClass -> {
val (classId, arrayDimensions) = castedValue.value
val klass = session.symbolProvider.getClassLikeSymbolByClassId(classId)?.fir as? FirRegularClass ?: return null
var type: ConeClassLikeType = klass.defaultType().replaceArgumentsWithStarProjections()
repeat(arrayDimensions) {
type = type.createArrayType()
}
return type
}
}
}
internal fun create(argumentType: ConeKotlinType): ConstantValue<*>? {
if (argumentType is ConeErrorType) return null
if (argumentType !is ConeClassLikeType) return null
compiler/fir/fir2ir/jvm-backend/src/org/jetbrains/kotlin/fir/backend/jvm/FirJvmTypeMapper.kt
+3 -7
View File
@@ -14,9 +14,7 @@ import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper
import org.jetbrains.kotlin.descriptors.ClassKind
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.FirSessionComponent
import org.jetbrains.kotlin.fir.declarations.FirRegularClass
import org.jetbrains.kotlin.fir.declarations.FirTypeParameter
import org.jetbrains.kotlin.fir.declarations.utils.classId
import org.jetbrains.kotlin.fir.declarations.utils.isInner
import org.jetbrains.kotlin.fir.declarations.utils.isLocal
import org.jetbrains.kotlin.fir.resolve.defaultType
@@ -34,7 +32,9 @@ import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol
import org.jetbrains.kotlin.fir.types.*
import org.jetbrains.kotlin.fir.types.impl.ConeTypeParameterTypeImpl
import org.jetbrains.kotlin.load.kotlin.TypeMappingMode
import org.jetbrains.kotlin.name.*
import org.jetbrains.kotlin.name.ClassId
import org.jetbrains.kotlin.name.SpecialNames
import org.jetbrains.kotlin.name.StandardClassIds
import org.jetbrains.kotlin.types.AbstractTypeMapper
import org.jetbrains.kotlin.types.TypeMappingContext
import org.jetbrains.kotlin.types.TypeSystemCommonBackendContext
@@ -224,10 +224,6 @@ class FirJvmTypeMapper(val session: FirSession) : FirSessionComponent {
fun segments(): List<PossiblyInnerConeType> = outerType?.segments().orEmpty() + this
}
fun getJvmShortName(klass: FirRegularClass): String {
return getJvmShortName(klass.classId)
}
internal fun getJvmShortName(classId: ClassId): String {
val result = runUnless(classId.isLocal) {
classId.asSingleFqName().toUnsafe().let { JavaToKotlinClassMap.mapKotlinToJava(it)?.shortClassName?.asString() }
compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/DelegatedMemberGenerator.kt
+6 -14
View File
@@ -11,12 +11,14 @@ import org.jetbrains.kotlin.fir.backend.*
import org.jetbrains.kotlin.fir.declarations.*
import org.jetbrains.kotlin.fir.declarations.utils.modality
import org.jetbrains.kotlin.fir.resolve.fullyExpandedType
import org.jetbrains.kotlin.fir.scopes.*
import org.jetbrains.kotlin.fir.delegatedWrapperData
import org.jetbrains.kotlin.fir.resolve.scope
import org.jetbrains.kotlin.fir.scopes.*
import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag
import org.jetbrains.kotlin.fir.symbols.impl.*
import org.jetbrains.kotlin.fir.types.*
import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol
import org.jetbrains.kotlin.fir.types.coneType
import org.jetbrains.kotlin.fir.types.lowerBoundIfFlexible
import org.jetbrains.kotlin.ir.declarations.*
import org.jetbrains.kotlin.ir.expressions.IrBlockBody
import org.jetbrains.kotlin.ir.expressions.impl.IrCallImpl
@@ -78,16 +80,6 @@ class DelegatedMemberGenerator(private val components: Fir2IrComponents) : Fir2I
bodiesInfo.clear()
}
private fun FirClassifierSymbol<*>?.boundClass(): FirClass {
return when (this) {
is FirRegularClassSymbol -> fir
is FirAnonymousObjectSymbol -> fir
is FirTypeParameterSymbol ->
fir.bounds.first().coneType.fullyExpandedType(session).lowerBoundIfFlexible().toSymbol(session).boundClass()
is FirTypeAliasSymbol, null -> throw AssertionError(this?.fir?.render())
}
}
// Generate delegated members for [subClass]. The synthetic field [irField] has the super interface type.
fun generate(irField: IrField, firField: FirField, firSubClass: FirClass, subClass: IrClass) {
val subClassScope = firSubClass.unsubstitutedScope(
compiler/fir/java/src/org/jetbrains/kotlin/fir/java/declarations/FirJavaClass.kt
-1
View File
@@ -154,7 +154,6 @@ class FirJavaClassBuilder : FirRegularClassBuilder(), FirAnnotationContainerBuil
var isFromSource: Boolean by Delegates.notNull()
var isTopLevel: Boolean by Delegates.notNull()
var isStatic: Boolean by Delegates.notNull()
var isNotSam: Boolean by Delegates.notNull()
var javaPackage: JavaPackage? = null
lateinit var javaTypeParameterStack: JavaTypeParameterStack
val existingNestedClassifierNames: MutableList<Name> = mutableListOf()
compiler/fir/java/src/org/jetbrains/kotlin/fir/java/declarations/FirJavaMethod.kt
-17
View File
@@ -27,19 +27,6 @@ import org.jetbrains.kotlin.fir.visitors.transformInplace
import org.jetbrains.kotlin.fir.visitors.transformSingle
import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedContainerSource
import org.jetbrains.kotlin.util.OperatorNameConventions.ASSIGNMENT_OPERATIONS
import org.jetbrains.kotlin.util.OperatorNameConventions.BINARY_OPERATION_NAMES
import org.jetbrains.kotlin.util.OperatorNameConventions.COMPARE_TO
import org.jetbrains.kotlin.util.OperatorNameConventions.CONTAINS
import org.jetbrains.kotlin.util.OperatorNameConventions.DELEGATED_PROPERTY_OPERATORS
import org.jetbrains.kotlin.util.OperatorNameConventions.EQUALS
import org.jetbrains.kotlin.util.OperatorNameConventions.GET
import org.jetbrains.kotlin.util.OperatorNameConventions.HAS_NEXT
import org.jetbrains.kotlin.util.OperatorNameConventions.INVOKE
import org.jetbrains.kotlin.util.OperatorNameConventions.ITERATOR
import org.jetbrains.kotlin.util.OperatorNameConventions.NEXT
import org.jetbrains.kotlin.util.OperatorNameConventions.SET
import org.jetbrains.kotlin.util.OperatorNameConventions.UNARY_OPERATION_NAMES
import kotlin.contracts.ExperimentalContracts
import kotlin.contracts.InvocationKind
import kotlin.contracts.contract
@@ -188,10 +175,6 @@ class FirJavaMethod @FirImplementationDetail constructor(
}
}
val ALL_JAVA_OPERATION_NAMES =
UNARY_OPERATION_NAMES + BINARY_OPERATION_NAMES + ASSIGNMENT_OPERATIONS + DELEGATED_PROPERTY_OPERATORS +
EQUALS + COMPARE_TO + CONTAINS + INVOKE + ITERATOR + GET + SET + NEXT + HAS_NEXT
@FirBuilderDsl
class FirJavaMethodBuilder : FirFunctionBuilder, FirTypeParametersOwnerBuilder, FirAnnotationContainerBuilder {
override var source: KtSourceElement? = null
compiler/fir/java/src/org/jetbrains/kotlin/fir/java/scopes/JavaScopeUtils.kt
-17
View File
@@ -78,23 +78,6 @@ object BuiltinMethodsWithSpecialGenericSignature {
val Name.sameAsBuiltinMethodWithErasedValueParameters: Boolean
get() = this in ERASED_VALUE_PARAMETERS_SHORT_NAMES
fun FirNamedFunctionSymbol.isBuiltinWithSpecialDescriptorInJvm(containingScope: FirTypeScope, session: FirSession): Boolean {
if (!isFromBuiltinClass(session)) return false
return getSpecialSignatureInfo(containingScope)?.isObjectReplacedWithTypeParameter ?: false ||
doesOverrideBuiltinWithDifferentJvmName(containingScope, session)
}
@JvmStatic
fun FirNamedFunctionSymbol.getSpecialSignatureInfo(containingScope: FirTypeScope): SpecialGenericSignatures.SpecialSignatureInfo? {
if (name !in ERASED_VALUE_PARAMETERS_SHORT_NAMES) return null
val builtinSignature = firstOverriddenFunction(containingScope) { it.hasErasedValueParametersInJava }
?.fir
?.computeJvmSignature()
?: return null
return SpecialGenericSignatures.getSpecialSignatureInfo(builtinSignature)
}
}
object BuiltinMethodsWithDifferentJvmName {
compiler/fir/modularized-tests/tests/org/jetbrains/kotlin/fir/AbstractModularizedTest.kt
-1
View File
@@ -34,7 +34,6 @@ data class ModuleData(
) {
val qualifiedName get() = if (name in qualifier) qualifier else "$name.$qualifier"
val outputDir = rawOutputDir.fixPath()
val classpath = rawClasspath.map { it.fixPath() }
val sources = rawSources.map { it.fixPath() }
val javaSourceRoots = rawJavaSourceRoots.map { JavaSourceRootData(it.path.fixPath(), it.packagePrefix) }
compiler/fir/providers/src/org/jetbrains/kotlin/fir/CopyUtils.kt
-11
View File
@@ -7,9 +7,7 @@ package org.jetbrains.kotlin.fir
import org.jetbrains.kotlin.builtins.StandardNames
import org.jetbrains.kotlin.fir.declarations.FirDeclaration
import org.jetbrains.kotlin.fir.declarations.toAnnotationClassId
import org.jetbrains.kotlin.fir.declarations.utils.expandedConeType
import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnostic
import org.jetbrains.kotlin.fir.expressions.*
import org.jetbrains.kotlin.fir.expressions.builder.FirImplicitInvokeCallBuilder
import org.jetbrains.kotlin.fir.expressions.builder.buildImplicitInvokeCall
@@ -64,15 +62,6 @@ fun FirTypeRef.resolvedTypeFromPrototype(
}
}
fun FirTypeRef.errorTypeFromPrototype(
diagnostic: ConeDiagnostic
): FirErrorTypeRef {
return buildErrorTypeRef {
source = this@errorTypeFromPrototype.source
this.diagnostic = diagnostic
}
}
/**
* [shouldExpandTypeAliases] should be set to `false` if this function is called during deserialization of some binary declaration
* For details see KT-57876
compiler/fir/providers/src/org/jetbrains/kotlin/fir/declarations/FirAnnotationUtils.kt
-1
View File
@@ -223,7 +223,6 @@ fun FirAnnotation.findArgumentByName(name: Name): FirExpression? {
fun FirAnnotation.getBooleanArgument(name: Name): Boolean? = getPrimitiveArgumentValue(name)
fun FirAnnotation.getStringArgument(name: Name): String? = getPrimitiveArgumentValue(name)
fun FirAnnotation.getIntArgument(name: Name): Int? = getPrimitiveArgumentValue(name)
fun FirAnnotation.getStringArrayArgument(name: Name): List<String>? {
val argument = findArgumentByName(name) as? FirArrayOfCall ?: return null
return argument.arguments.mapNotNull { (it as? FirConstExpression<*>)?.value as? String }
compiler/fir/providers/src/org/jetbrains/kotlin/fir/declarations/contractSubstitutions.kt
-29
View File
@@ -6,10 +6,6 @@
package org.jetbrains.kotlin.fir.declarations
import org.jetbrains.kotlin.fir.contracts.FirContractDescription
import org.jetbrains.kotlin.fir.contracts.FirEffectDeclaration
import org.jetbrains.kotlin.fir.contracts.FirResolvedContractDescription
import org.jetbrains.kotlin.fir.contracts.builder.buildEffectDeclaration
import org.jetbrains.kotlin.fir.contracts.builder.buildResolvedContractDescription
import org.jetbrains.kotlin.fir.contracts.description.*
import org.jetbrains.kotlin.fir.contracts.impl.FirEmptyContractDescription
import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
@@ -17,31 +13,6 @@ import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
val FirContractDescription?.isNullOrEmpty: Boolean
get() = (this == null) || (this is FirEmptyContractDescription)
fun FirContractDescription.createContractDescriptionForSubstitutionOverride(substitutor: ConeSubstitutor?): FirContractDescription {
if (this !is FirResolvedContractDescription) return this
if (substitutor == null || substitutor == ConeSubstitutor.Empty) return this
return createContractDescriptionForSubstitutionOverride(substitutor)
}
private fun FirResolvedContractDescription.createContractDescriptionForSubstitutionOverride(
substitutor: ConeSubstitutor
): FirResolvedContractDescription {
val original = this
return buildResolvedContractDescription {
source = original.source
original.effects.mapTo(effects) { it.substitute(substitutor) }
unresolvedEffects.addAll(original.unresolvedEffects)
}
}
private fun FirEffectDeclaration.substitute(substitutor: ConeSubstitutor): FirEffectDeclaration {
val original = this
return buildEffectDeclaration {
source = original.source
effect = original.effect.substitute(substitutor)
}
}
private fun ConeEffectDeclaration.substitute(substitutor: ConeSubstitutor): ConeEffectDeclaration {
return when (this) {
is ConeConditionalEffectDeclaration -> ConeConditionalEffectDeclaration(
compiler/fir/providers/src/org/jetbrains/kotlin/fir/declarations/declarationUtils.kt
-27
View File
@@ -18,7 +18,6 @@ import org.jetbrains.kotlin.fir.types.ConeClassLikeType
import org.jetbrains.kotlin.fir.types.coneType
import org.jetbrains.kotlin.fir.types.coneTypeSafe
import org.jetbrains.kotlin.fir.types.toSymbol
import org.jetbrains.kotlin.utils.addToStdlib.runIf
fun FirClass.constructors(session: FirSession): List<FirConstructorSymbol> {
val result = mutableListOf<FirConstructorSymbol>()
@@ -26,10 +25,6 @@ fun FirClass.constructors(session: FirSession): List<FirConstructorSymbol> {
return result
}
fun FirClass.constructorsSortedByDelegation(session: FirSession): List<FirConstructorSymbol> {
return constructors(session).sortedWith(ConstructorDelegationComparator)
}
fun FirClass.primaryConstructorIfAny(session: FirSession): FirConstructorSymbol? {
return constructors(session).find(FirConstructorSymbol::isPrimary)
}
@@ -44,23 +39,6 @@ fun FirClassSymbol<*>.collectEnumEntries(): Collection<FirEnumEntrySymbol> {
return fir.collectEnumEntries().map { it.symbol }
}
val FirConstructorSymbol.delegatedThisConstructor: FirConstructorSymbol?
get() = runIf(delegatedConstructorCallIsThis) { this.resolvedDelegatedConstructor }
private object ConstructorDelegationComparator : Comparator<FirConstructorSymbol> {
override fun compare(p0: FirConstructorSymbol?, p1: FirConstructorSymbol?): Int {
if (p0 == null && p1 == null) return 0
if (p0 == null) return -1
if (p1 == null) return 1
if (p0.delegatedThisConstructor == p1) return 1
if (p1.delegatedThisConstructor == p0) return -1
// If neither is a delegation to each other, the order doesn't matter.
// Here we return 0 to preserve the original order.
return 0
}
}
/**
* Returns the FirClassLikeDeclaration that the
* sequence of FirTypeAlias'es points to starting
@@ -80,11 +58,6 @@ fun FirBasedSymbol<*>.isAnnotationConstructor(session: FirSession): Boolean {
return getConstructedClass(session)?.classKind == ClassKind.ANNOTATION_CLASS
}
fun FirBasedSymbol<*>.isEnumConstructor(session: FirSession): Boolean {
if (this !is FirConstructorSymbol) return false
return getConstructedClass(session)?.classKind == ClassKind.ENUM_CLASS
}
fun FirBasedSymbol<*>.isPrimaryConstructorOfInlineOrValueClass(session: FirSession): Boolean {
if (this !is FirConstructorSymbol) return false
return getConstructedClass(session)?.isInlineOrValueClass() == true && this.isPrimary
compiler/fir/providers/src/org/jetbrains/kotlin/fir/extensions/FirDeclarationGenerationExtension.kt
-7
View File
@@ -6,7 +6,6 @@
package org.jetbrains.kotlin.fir.extensions
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.caches.FirCache
import org.jetbrains.kotlin.fir.caches.FirLazyValue
import org.jetbrains.kotlin.fir.caches.firCachesFactory
import org.jetbrains.kotlin.fir.scopes.FirContainingNamesAwareScope
@@ -78,12 +77,6 @@ abstract class FirDeclarationGenerationExtension(session: FirSession) : FirExten
// ----------------------------------- internal utils -----------------------------------
@FirExtensionApiInternals
val nestedClassifierNamesCache: FirCache<FirClassSymbol<*>, Set<Name>, NestedClassGenerationContext> =
session.firCachesFactory.createCache { symbol, context ->
getNestedClassifiersNames(symbol, context)
}
@FirExtensionApiInternals
val topLevelClassIdsCache: FirLazyValue<Set<ClassId>> =
session.firCachesFactory.createLazyValue { getTopLevelClassIds() }
compiler/fir/providers/src/org/jetbrains/kotlin/fir/resolve/LookupTagUtils.kt
-3
View File
@@ -47,9 +47,6 @@ fun ConeClassLikeLookupTag.toSymbol(useSiteSession: FirSession): FirClassLikeSym
}
}
fun ConeClassLikeLookupTag.toSymbolOrError(useSiteSession: FirSession): FirClassLikeSymbol<*> =
toSymbol(useSiteSession) ?: error("Class symbol with classId $classId was not found")
fun ConeClassLikeLookupTag.toFirRegularClassSymbol(session: FirSession): FirRegularClassSymbol? =
toSymbol(session) as? FirRegularClassSymbol
compiler/fir/providers/src/org/jetbrains/kotlin/fir/scopes/FirKotlinScopeProvider.kt
+4 -5
View File
@@ -12,7 +12,10 @@ import org.jetbrains.kotlin.fir.declarations.FirClass
import org.jetbrains.kotlin.fir.declarations.FirDeclarationOrigin
import org.jetbrains.kotlin.fir.declarations.FirRegularClass
import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
import org.jetbrains.kotlin.fir.declarations.utils.*
import org.jetbrains.kotlin.fir.declarations.utils.delegateFields
import org.jetbrains.kotlin.fir.declarations.utils.isData
import org.jetbrains.kotlin.fir.declarations.utils.isExpect
import org.jetbrains.kotlin.fir.declarations.utils.isInline
import org.jetbrains.kotlin.fir.resolve.*
import org.jetbrains.kotlin.fir.resolve.substitution.ConeRawScopeSubstitutor
import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
@@ -115,10 +118,6 @@ data class ConeSubstitutionScopeKey(
val derivedClassLookupTag: ConeClassLikeLookupTag?
) : ScopeSessionKey<FirClass, FirClassSubstitutionScope>()
data class AnySynthesizedScopeKey(
val lookupTag: ConeClassLikeLookupTag
) : ScopeSessionKey<ConeClassLikeLookupTag, FirClassAnySynthesizedMemberScope>()
fun FirClass.unsubstitutedScope(
useSiteSession: FirSession,
scopeSession: ScopeSession,
compiler/fir/providers/src/org/jetbrains/kotlin/fir/scopes/FirOverrideService.kt
-15
View File
@@ -19,23 +19,8 @@ import org.jetbrains.kotlin.fir.types.ConeFlexibleType
import org.jetbrains.kotlin.fir.types.ConeKotlinType
import org.jetbrains.kotlin.fir.types.typeContext
import org.jetbrains.kotlin.types.AbstractTypeChecker
import java.util.*
class FirOverrideService(val session: FirSession) : FirSessionComponent {
fun <D : FirCallableSymbol<*>> createOverridableGroups(
members: Collection<MemberWithBaseScope<D>>,
overrideChecker: FirOverrideChecker
): List<List<MemberWithBaseScope<D>>> {
if (members.size <= 1) return listOf(members.toList())
val queue = LinkedList(members)
val result = mutableListOf<List<MemberWithBaseScope<D>>>()
while (queue.isNotEmpty()) {
val nextHandle = queue.first()
val overridableGroup = extractBothWaysOverridable(nextHandle, queue, overrideChecker)
result += overridableGroup
}
return result
}
fun <D : FirCallableSymbol<*>> extractBothWaysOverridable(
overrider: MemberWithBaseScope<D>,
compiler/fir/providers/src/org/jetbrains/kotlin/fir/types/ConeNullabilityChecker.kt
-19
View File
@@ -1,19 +0,0 @@
/*
* Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
* Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
*/
package org.jetbrains.kotlin.fir.types
import org.jetbrains.kotlin.types.AbstractNullabilityChecker
import org.jetbrains.kotlin.types.TypeCheckerState
object ConeNullabilityChecker {
fun isSubtypeOfAny(context: ConeTypeContext, type: ConeKotlinType): Boolean {
val actualType = with(context) { type.lowerBoundIfFlexible() }
return with(AbstractNullabilityChecker) {
context.newTypeCheckerState(errorTypesEqualToAnything = false, stubTypesEqualToAnything = true)
.hasNotNullSupertype(actualType, TypeCheckerState.SupertypesPolicy.LowerIfFlexible)
}
}
}
compiler/fir/providers/src/org/jetbrains/kotlin/fir/types/FunctionalTypeUtils.kt
-11
View File
@@ -104,17 +104,6 @@ fun ConeKotlinType.customFunctionTypeToSimpleFunctionType(session: FirSession):
return createFunctionTypeWithNewKind(session, newKind)
}
/*
* KFunction -> Function
* KSuspendFunction -> SuspendFunction
* K[Custom]Function -> [Custom]Function
*/
fun ConeKotlinType.reflectFunctionTypeToNonReflectFunctionType(session: FirSession): ConeClassLikeType {
val kind = functionTypeKind(session)
require(kind != null && kind.isReflectType)
return createFunctionTypeWithNewKind(session, kind.nonReflectKind())
}
private fun ConeKotlinType.createFunctionTypeWithNewKind(session: FirSession, kind: FunctionTypeKind): ConeClassLikeType {
val expandedType = fullyExpandedType(session)
val functionTypeId = ClassId(kind.packageFqName, kind.numberedClassName(expandedType.typeArguments.size - 1))
compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/converter/AbstractLightTreeRawFirBuilder.kt
-10
View File
@@ -139,16 +139,6 @@ abstract class AbstractLightTreeRawFirBuilder(
return tree.getParent(this)
}
fun LighterASTNode.getParents(): Sequence<LighterASTNode> {
var node = this
return sequence {
while (true) {
yield(node)
node = node.getParent() ?: break
}
}
}
fun LighterASTNode?.getChildNodesByType(type: IElementType): List<LighterASTNode> {
return this?.forEachChildrenReturnList { node, container ->
when (node.tokenType) {
compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/fir/ClassWrapper.kt
-3
View File
@@ -25,9 +25,6 @@ class ClassWrapper(
val delegatedSuperTypeRef: FirTypeRef,
val delegatedSuperCalls: List<DelegatedConstructorWrapper>,
) {
fun isObjectLiteral(): Boolean {
return className == SpecialNames.NO_NAME_PROVIDED && isObject()
}
fun isEnumEntry(): Boolean {
return classKind == ClassKind.ENUM_ENTRY
compiler/fir/raw-fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/PsiRawFirBuilder.kt
-4
View File
@@ -82,10 +82,6 @@ open class PsiRawFirBuilder(
return Visitor().visitAnnotationEntry(annotation, null) as FirAnnotationCall
}
fun buildTypeReference(reference: KtTypeReference): FirTypeRef {
return reference.accept(Visitor(), null) as FirTypeRef
}
override fun PsiElement.toFirSourceElement(kind: KtFakeSourceElementKind?): KtPsiSourceElement {
val actualKind = kind ?: this@PsiRawFirBuilder.context.forcedElementSourceKind ?: KtRealSourceElementKind
return this.toKtPsiSourceElement(actualKind)
compiler/fir/raw-fir/raw-fir.common/src/org/jetbrains/kotlin/fir/builder/Context.kt
-2
View File
@@ -13,7 +13,6 @@ import org.jetbrains.kotlin.fir.PrivateForInline
import org.jetbrains.kotlin.fir.declarations.FirTypeParameterRef
import org.jetbrains.kotlin.fir.declarations.builder.buildOuterClassTypeParameterRef
import org.jetbrains.kotlin.fir.expressions.FirExpression
import org.jetbrains.kotlin.fir.symbols.impl.FirFileSymbol
import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol
import org.jetbrains.kotlin.fir.types.ConeClassLikeType
import org.jetbrains.kotlin.name.ClassId
@@ -49,7 +48,6 @@ class Context<T> {
var forcedElementSourceKind: KtSourceElementKind? = null
val dispatchReceiverTypesStack = mutableListOf<ConeClassLikeType>()
var containerIsExpect: Boolean = false
var containingFileSymbol: FirFileSymbol? = null
fun pushFirTypeParameters(isInnerOrLocal: Boolean, parameters: List<FirTypeParameterRef>) {
capturedTypeParameters.add(StatusFirTypeParameterSymbolList(isInnerOrLocal, parameters.map { it.symbol }))
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/cfg/ControlFlowGraphNodeBuilder.kt
-6
View File
@@ -160,12 +160,6 @@ fun ControlFlowGraphBuilder.createConstExpressionNode(fir: FirConstExpression<*>
fun ControlFlowGraphBuilder.createThrowExceptionNode(fir: FirThrowExpression): ThrowExceptionNode =
ThrowExceptionNode(currentGraph, fir, levelCounter)
fun ControlFlowGraphBuilder.createFinallyProxyExitNode(fir: FirTryExpression): FinallyProxyExitNode =
FinallyProxyExitNode(currentGraph, fir, levelCounter)
fun ControlFlowGraphBuilder.createFinallyProxyEnterNode(fir: FirTryExpression): FinallyProxyEnterNode =
FinallyProxyEnterNode(currentGraph, fir, levelCounter)
fun ControlFlowGraphBuilder.createFinallyBlockExitNode(fir: FirTryExpression): FinallyBlockExitNode =
FinallyBlockExitNode(currentGraph, fir, levelCounter)
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/BodyResolveContext.kt
-3
View File
@@ -90,9 +90,6 @@ class BodyResolveContext(
var containingClassDeclarations: ArrayDeque<FirRegularClass> = ArrayDeque()
val topClassDeclaration: FirRegularClass?
get() = containingClassDeclarations.lastOrNull()
@OptIn(PrivateForInline::class)
inline fun <T> withTowerDataContexts(newContexts: FirRegularTowerDataContexts, f: () -> T): T {
val old = regularTowerDataContexts
compiler/fir/semantics/src/org/jetbrains/kotlin/fir/resolve/dfa/cfg/CFGNode.kt
+1 -12
View File
@@ -522,18 +522,7 @@ class FinallyBlockExitNode(owner: ControlFlowGraph, override val fir: FirTryExpr
return visitor.visitFinallyBlockExitNode(this, data)
}
}
class FinallyProxyEnterNode(owner: ControlFlowGraph, override val fir: FirTryExpression, level: Int) : CFGNode<FirTryExpression>(owner, level),
EnterNodeMarker {
override fun <R, D> accept(visitor: ControlFlowGraphVisitor<R, D>, data: D): R {
return visitor.visitFinallyProxyEnterNode(this, data)
}
}
class FinallyProxyExitNode(owner: ControlFlowGraph, override val fir: FirTryExpression, level: Int) : CFGNode<FirTryExpression>(owner, level),
ExitNodeMarker {
override fun <R, D> accept(visitor: ControlFlowGraphVisitor<R, D>, data: D): R {
return visitor.visitFinallyProxyExitNode(this, data)
}
}
class TryExpressionExitNode(owner: ControlFlowGraph, override val fir: FirTryExpression, level: Int) : CFGNode<FirTryExpression>(owner, level),
ExitNodeMarker {
override fun <R, D> accept(visitor: ControlFlowGraphVisitor<R, D>, data: D): R {
compiler/fir/semantics/src/org/jetbrains/kotlin/fir/resolve/dfa/cfg/CFGNodeRenderer.kt
+4 -3
View File
@@ -5,7 +5,10 @@
package org.jetbrains.kotlin.fir.resolve.dfa.cfg
import org.jetbrains.kotlin.fir.expressions.*
import org.jetbrains.kotlin.fir.expressions.FirDoWhileLoop
import org.jetbrains.kotlin.fir.expressions.FirLoop
import org.jetbrains.kotlin.fir.expressions.FirWhileLoop
import org.jetbrains.kotlin.fir.expressions.calleeReference
import org.jetbrains.kotlin.fir.expressions.impl.FirElseIfTrueCondition
import org.jetbrains.kotlin.fir.render
import org.jetbrains.kotlin.fir.renderer.FirCallNoArgumentsRenderer
@@ -66,8 +69,6 @@ fun CFGNode<*>.render(): String =
is CatchClauseExitNode -> "Catch exit"
is FinallyBlockEnterNode -> "Enter finally"
is FinallyBlockExitNode -> "Exit finally"
is FinallyProxyEnterNode -> TODO()
is FinallyProxyExitNode -> TODO()
is TryExpressionExitNode -> "Try expression exit"
is BinaryAndEnterNode -> "Enter &&"
compiler/fir/semantics/src/org/jetbrains/kotlin/fir/resolve/dfa/cfg/ControlFlowGraphVisitor.kt
-8
View File
@@ -231,14 +231,6 @@ abstract class ControlFlowGraphVisitor<out R, in D> {
return visitNode(node, data)
}
open fun visitFinallyProxyEnterNode(node: FinallyProxyEnterNode, data: D): R {
return visitNode(node, data)
}
open fun visitFinallyProxyExitNode(node: FinallyProxyExitNode, data: D): R {
return visitNode(node, data)
}
open fun visitTryExpressionExitNode(node: TryExpressionExitNode, data: D): R {
return visitNode(node, data)
}
compiler/fir/semantics/src/org/jetbrains/kotlin/fir/resolve/dfa/cfg/ControlFlowGraphVisitorVoid.kt
-16
View File
@@ -161,14 +161,6 @@ abstract class ControlFlowGraphVisitorVoid : ControlFlowGraphVisitor<Unit, Nothi
visitNode(node)
}
open fun visitFinallyProxyEnterNode(node: FinallyProxyEnterNode) {
visitNode(node)
}
open fun visitFinallyProxyExitNode(node: FinallyProxyExitNode) {
visitNode(node)
}
open fun visitTryExpressionExitNode(node: TryExpressionExitNode) {
visitNode(node)
}
@@ -442,14 +434,6 @@ abstract class ControlFlowGraphVisitorVoid : ControlFlowGraphVisitor<Unit, Nothi
visitFinallyBlockExitNode(node)
}
final override fun visitFinallyProxyEnterNode(node: FinallyProxyEnterNode, data: Nothing?) {
visitFinallyProxyEnterNode(node)
}
final override fun visitFinallyProxyExitNode(node: FinallyProxyExitNode, data: Nothing?) {
visitFinallyProxyExitNode(node)
}
final override fun visitTryExpressionExitNode(node: TryExpressionExitNode, data: Nothing?) {
visitTryExpressionExitNode(node)
}
compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/utils/FirSymbolStatusUtils.kt
-7
View File
@@ -24,9 +24,6 @@ inline val FirCallableSymbol<*>.isFinal: Boolean
inline val FirCallableSymbol<*>.visibility: Visibility get() = resolvedStatus.visibility
inline val FirCallableSymbol<*>.effectiveVisibility: EffectiveVisibility get() = resolvedStatus.effectiveVisibility
inline val FirCallableSymbol<*>.allowsToHaveFakeOverride: Boolean
get() = !Visibilities.isPrivate(visibility) && visibility != Visibilities.InvisibleFake
inline val FirCallableSymbol<*>.isActual: Boolean get() = rawStatus.isActual
inline val FirCallableSymbol<*>.isExpect: Boolean get() = rawStatus.isExpect
inline val FirCallableSymbol<*>.isInner: Boolean get() = rawStatus.isInner
@@ -48,7 +45,6 @@ inline val FirCallableSymbol<*>.isFun: Boolean get() = rawStatus.isFun
inline val FirClassLikeSymbol<*>.modality: Modality? get() = resolvedStatus.modality
inline val FirClassLikeSymbol<*>.isAbstract: Boolean get() = resolvedStatus.modality == Modality.ABSTRACT
inline val FirClassLikeSymbol<*>.isOpen: Boolean get() = resolvedStatus.modality == Modality.OPEN
inline val FirClassLikeSymbol<*>.isFinal: Boolean
get() {
// member with unspecified modality is final
@@ -72,9 +68,6 @@ inline val FirClassLikeSymbol<*>.isCompanion: Boolean get() = rawStatus.isCompan
inline val FirClassLikeSymbol<*>.isData: Boolean get() = rawStatus.isData
inline val FirClassLikeSymbol<*>.isSealed: Boolean get() = resolvedStatus.modality == Modality.SEALED
inline val FirRegularClassSymbol.canHaveAbstractDeclaration: Boolean
get() = isAbstract || isSealed || isEnumClass
// ---------------------- common classes ----------------------
inline val FirClassLikeSymbol<*>.isLocal: Boolean get() = classId.isLocal
compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/utils/declarationAttributes.kt
-4
View File
@@ -69,10 +69,6 @@ fun FirProperty.getExplicitBackingField(): FirBackingField? {
}
}
fun FirPropertySymbol.getExplicitBackingField(): FirBackingField? {
return fir.getExplicitBackingField()
}
val FirProperty.canNarrowDownGetterType: Boolean
get() {
val backingFieldHasDifferentType = backingField != null && backingField?.returnTypeRef?.coneType != returnTypeRef.coneType
compiler/fir/tree/src/org/jetbrains/kotlin/fir/visitors/FirTransformerUtil.kt
+1 -9
View File
@@ -47,12 +47,4 @@ inline fun <T : FirElement, D> MutableList<T>.transformInplace(transformer: FirT
iterator.set(result)
}
}
}
fun <R, D> List<FirElement>.acceptAllElements(visitor: FirVisitor<R, D>, data: D) {
forEach { it.accept(visitor, data) }
}
fun List<FirElement>.acceptAllElements(visitor: FirVisitorVoid) {
forEach { it.accept(visitor) }
}
}
compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/BuilderConfigurator.kt
+4 -15
View File
@@ -6,7 +6,10 @@
package org.jetbrains.kotlin.fir.tree.generator
import org.jetbrains.kotlin.fir.tree.generator.context.AbstractBuilderConfigurator
import org.jetbrains.kotlin.fir.tree.generator.model.*
import org.jetbrains.kotlin.fir.tree.generator.model.Element
import org.jetbrains.kotlin.fir.tree.generator.model.Field
import org.jetbrains.kotlin.fir.tree.generator.model.Implementation
import org.jetbrains.kotlin.fir.tree.generator.model.LeafBuilder
import org.jetbrains.kotlin.fir.tree.generator.printer.invisibleField
import org.jetbrains.kotlin.fir.tree.generator.util.traverseParents
@@ -509,18 +512,4 @@ object BuilderConfigurator : AbstractBuilderConfigurator<FirTreeBuilder>(FirTree
}
}
private fun configureFieldInAllIntermediateBuilders(
field: String,
builderPredicate: ((IntermediateBuilder) -> Boolean)? = null,
fieldPredicate: ((Field) -> Boolean)? = null,
init: IntermediateBuilderConfigurationContext.(field: String) -> Unit
) {
for (builder in FirTreeBuilder.intermediateBuilders) {
if (builderPredicate != null && !builderPredicate(builder)) continue
if (!builder.allFields.any { it.name == field }) continue
if (fieldPredicate != null && !fieldPredicate(builder[field])) continue
IntermediateBuilderConfigurationContext(builder).init(field)
}
}
}