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

[LL FIR] FirLazyBodiesCalculator: drop obsolete logic for compiler required annotations

Browse Source 
We have custom logic on `LLFirCompilerRequiredAnnotationsTargetResolver`
side
This commit is contained in:
Dmitrii Gridin
2024-02-13 20:30:00 +01:00
committed by Space Team
parent f5f3b7fec0
commit 58a1662c02
1 changed files with 20 additions and 46 deletions
Download Patch File Download Diff File Expand all files Collapse all files
analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/lazy/resolve/FirLazyBodiesCalculator.kt
+20 -46
View File
@@ -22,7 +22,6 @@ import org.jetbrains.kotlin.fir.declarations.utils.getExplicitBackingField
import org.jetbrains.kotlin.fir.expressions.* import org.jetbrains.kotlin.fir.expressions.*
import org.jetbrains.kotlin.fir.expressions.impl.FirLazyDelegatedConstructorCall import org.jetbrains.kotlin.fir.expressions.impl.FirLazyDelegatedConstructorCall
import org.jetbrains.kotlin.fir.expressions.impl.FirSingleExpressionBlock import org.jetbrains.kotlin.fir.expressions.impl.FirSingleExpressionBlock
import org.jetbrains.kotlin.fir.extensions.registeredPluginAnnotations
import org.jetbrains.kotlin.fir.references.FirDelegateFieldReference import org.jetbrains.kotlin.fir.references.FirDelegateFieldReference
import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
import org.jetbrains.kotlin.fir.references.builder.buildDelegateFieldReference import org.jetbrains.kotlin.fir.references.builder.buildDelegateFieldReference
@@ -54,7 +53,7 @@ internal object FirLazyBodiesCalculator {
} }
fun calculateAllLazyExpressionsInFile(firFile: FirFile) { fun calculateAllLazyExpressionsInFile(firFile: FirFile) {
firFile.transformSingle(FirAllLazyAnnotationCalculatorTransformer, FirLazyAnnotationTransformerData(firFile.moduleData.session)) firFile.transformSingle(FirAllLazyAnnotationCalculatorTransformer, firFile.moduleData.session)
firFile.transformSingle(FirAllLazyBodiesCalculatorTransformer, persistentListOf()) firFile.transformSingle(FirAllLazyBodiesCalculatorTransformer, persistentListOf())
} }
@@ -63,7 +62,7 @@ internal object FirLazyBodiesCalculator {
} }
fun calculateAnnotations(firElement: FirElement, session: FirSession) { fun calculateAnnotations(firElement: FirElement, session: FirSession) {
firElement.transformSingle(FirTargetLazyAnnotationCalculatorTransformer, FirLazyAnnotationTransformerData(session)) firElement.transformSingle(FirTargetLazyAnnotationCalculatorTransformer, session)
} }
fun calculateLazyArgumentsForAnnotation(annotationCall: FirAnnotationCall, session: FirSession): FirArgumentList { fun calculateLazyArgumentsForAnnotation(annotationCall: FirAnnotationCall, session: FirSession): FirArgumentList {
@@ -625,29 +624,20 @@ private fun calculateLazyBodyForCodeFragment(designation: FirDesignation) {
codeFragment.replaceBlock(newCodeFragment.block) codeFragment.replaceBlock(newCodeFragment.block)
} }
private enum class FirLazyAnnotationTransformerScope {
ALL_ANNOTATIONS,
}
private data class FirLazyAnnotationTransformerData(
val session: FirSession,
val compilerAnnotationsOnly: FirLazyAnnotationTransformerScope = FirLazyAnnotationTransformerScope.ALL_ANNOTATIONS,
)
private object FirAllLazyAnnotationCalculatorTransformer : FirLazyAnnotationTransformer() { private object FirAllLazyAnnotationCalculatorTransformer : FirLazyAnnotationTransformer() {
override fun <E : FirElement> transformElement(element: E, data: FirLazyAnnotationTransformerData): E { override fun <E : FirElement> transformElement(element: E, data: FirSession): E {
element.transformChildren(this, data) element.transformChildren(this, data)
return element return element
} }
} }
private object FirTargetLazyAnnotationCalculatorTransformer : FirLazyAnnotationTransformer() { private object FirTargetLazyAnnotationCalculatorTransformer : FirLazyAnnotationTransformer() {
override fun <E : FirElement> transformElement(element: E, data: FirLazyAnnotationTransformerData): E { override fun <E : FirElement> transformElement(element: E, data: FirSession): E {
element.transformChildren(this, data) element.transformChildren(this, data)
return element return element
} }
override fun transformRegularClass(regularClass: FirRegularClass, data: FirLazyAnnotationTransformerData): FirStatement { override fun transformRegularClass(regularClass: FirRegularClass, data: FirSession): FirStatement {
regularClass.transformAnnotations(this, data) regularClass.transformAnnotations(this, data)
regularClass.transformTypeParameters(this, data) regularClass.transformTypeParameters(this, data)
regularClass.transformSuperTypeRefs(this, data) regularClass.transformSuperTypeRefs(this, data)
@@ -658,47 +648,39 @@ private object FirTargetLazyAnnotationCalculatorTransformer : FirLazyAnnotationT
return regularClass return regularClass
} }
override fun transformScript(script: FirScript, data: FirLazyAnnotationTransformerData): FirScript { override fun transformScript(script: FirScript, data: FirSession): FirScript {
script.transformAnnotations(this, data) script.transformAnnotations(this, data)
return script return script
} }
override fun transformBlock(block: FirBlock, data: FirLazyAnnotationTransformerData): FirStatement { override fun transformBlock(block: FirBlock, data: FirSession): FirStatement {
// We shouldn't process blocks because there are no lazy annotations // We shouldn't process blocks because there are no lazy annotations
return block return block
} }
override fun transformFile(file: FirFile, data: FirLazyAnnotationTransformerData): FirFile { override fun transformFile(file: FirFile, data: FirSession): FirFile {
file.transformAnnotationsContainer(this, data) file.transformAnnotationsContainer(this, data)
return file return file
} }
} }
private abstract class FirLazyAnnotationTransformer : FirTransformer<FirLazyAnnotationTransformerData>() { private abstract class FirLazyAnnotationTransformer : FirTransformer<FirSession>() {
override fun <E : FirElement> transformElement(element: E, data: FirLazyAnnotationTransformerData): E { override fun <E : FirElement> transformElement(element: E, data: FirSession): E {
element.transformChildren(this, data) element.transformChildren(this, data)
return element return element
} }
private fun canBeCompilerAnnotation(annotationCall: FirAnnotationCall, session: FirSession): Boolean { override fun transformErrorTypeRef(errorTypeRef: FirErrorTypeRef, data: FirSession): FirTypeRef {
val annotationTypeRef = annotationCall.annotationTypeRef
if (annotationTypeRef !is FirUserTypeRef) return false
if (session.registeredPluginAnnotations.annotations.isNotEmpty()) return true
val name = annotationTypeRef.qualifier.last().name
return name in session.annotationPlatformSupport.requiredAnnotationsShortClassNames
}
override fun transformErrorTypeRef(errorTypeRef: FirErrorTypeRef, data: FirLazyAnnotationTransformerData): FirTypeRef {
visitTypeAnnotations(errorTypeRef, data) visitTypeAnnotations(errorTypeRef, data)
return super.transformErrorTypeRef(errorTypeRef, data) return super.transformErrorTypeRef(errorTypeRef, data)
} }
override fun transformResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef, data: FirLazyAnnotationTransformerData): FirTypeRef { override fun transformResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef, data: FirSession): FirTypeRef {
visitTypeAnnotations(resolvedTypeRef, data) visitTypeAnnotations(resolvedTypeRef, data)
return super.transformResolvedTypeRef(resolvedTypeRef, data) return super.transformResolvedTypeRef(resolvedTypeRef, data)
} }
private fun visitTypeAnnotations(resolvedTypeRef: FirResolvedTypeRef, data: FirLazyAnnotationTransformerData) { private fun visitTypeAnnotations(resolvedTypeRef: FirResolvedTypeRef, data: FirSession) {
resolvedTypeRef.coneType.forEachType { coneType -> resolvedTypeRef.coneType.forEachType { coneType ->
for (typeArgumentAnnotation in coneType.customAnnotations) { for (typeArgumentAnnotation in coneType.customAnnotations) {
typeArgumentAnnotation.accept(this, data) typeArgumentAnnotation.accept(this, data)
@@ -706,11 +688,9 @@ private abstract class FirLazyAnnotationTransformer : FirTransformer<FirLazyAnno
} }
} }
override fun transformAnnotationCall(annotationCall: FirAnnotationCall, data: FirLazyAnnotationTransformerData): FirStatement { override fun transformAnnotationCall(annotationCall: FirAnnotationCall, data: FirSession): FirStatement {
val shouldCalculate = data.compilerAnnotationsOnly == FirLazyAnnotationTransformerScope.ALL_ANNOTATIONS || if (FirLazyBodiesCalculator.needCalculatingAnnotationCall(annotationCall)) {
canBeCompilerAnnotation(annotationCall, data.session) val newArgumentList = FirLazyBodiesCalculator.calculateLazyArgumentsForAnnotation(annotationCall, data)
if (shouldCalculate && FirLazyBodiesCalculator.needCalculatingAnnotationCall(annotationCall)) {
val newArgumentList = FirLazyBodiesCalculator.calculateLazyArgumentsForAnnotation(annotationCall, data.session)
annotationCall.replaceArgumentList(newArgumentList) annotationCall.replaceArgumentList(newArgumentList)
} }
@@ -718,15 +698,12 @@ private abstract class FirLazyAnnotationTransformer : FirTransformer<FirLazyAnno
return annotationCall return annotationCall
} }
override fun transformErrorAnnotationCall( override fun transformErrorAnnotationCall(errorAnnotationCall: FirErrorAnnotationCall, data: FirSession): FirStatement {
errorAnnotationCall: FirErrorAnnotationCall,
data: FirLazyAnnotationTransformerData,
): FirStatement {
transformAnnotationCall(errorAnnotationCall, data) transformAnnotationCall(errorAnnotationCall, data)
return errorAnnotationCall return errorAnnotationCall
} }
override fun transformExpression(expression: FirExpression, data: FirLazyAnnotationTransformerData): FirStatement { override fun transformExpression(expression: FirExpression, data: FirSession): FirStatement {
if (expression is FirLazyExpression) { if (expression is FirLazyExpression) {
return expression return expression
} }
@@ -734,7 +711,7 @@ private abstract class FirLazyAnnotationTransformer : FirTransformer<FirLazyAnno
return super.transformExpression(expression, data) return super.transformExpression(expression, data)
} }
override fun transformBlock(block: FirBlock, data: FirLazyAnnotationTransformerData): FirStatement { override fun transformBlock(block: FirBlock, data: FirSession): FirStatement {
if (block is FirLazyBlock) { if (block is FirLazyBlock) {
return block return block
} }
@@ -742,10 +719,7 @@ private abstract class FirLazyAnnotationTransformer : FirTransformer<FirLazyAnno
return super.transformBlock(block, data) return super.transformBlock(block, data)
} }
override fun transformDelegatedConstructorCall( override fun transformDelegatedConstructorCall(delegatedConstructorCall: FirDelegatedConstructorCall, data: FirSession): FirStatement {
delegatedConstructorCall: FirDelegatedConstructorCall,
data: FirLazyAnnotationTransformerData,
): FirStatement {
if (delegatedConstructorCall is FirLazyDelegatedConstructorCall) { if (delegatedConstructorCall is FirLazyDelegatedConstructorCall) {
return delegatedConstructorCall return delegatedConstructorCall
} }