Fir2IrConverter: unite two process*Members functions in processClassMembers

2023-06-26 11:20:35 +03:00
parent 2e5ae122ea
commit 595aace885
5 changed files with 31 additions and 63 deletions
@@ -246,7 +246,7 @@ class Fir2IrClassifierStorage(
        // If non-local classes are already created (this means we are in body translation) we do everything immediately
        // The last variant is possible for local variables like 'val a = object : Any() { ... }'
        if (processMembersOfClassesOnTheFlyImmediately) {
-            processMembersOfClassCreatedOnTheFly(classOrLocalParent, result)
+            converter.processClassMembers(classOrLocalParent, result)
            converter.bindFakeOverridesInClass(result)
        } else {
            localClassesCreatedOnTheFly[classOrLocalParent] = result
@@ -262,7 +262,7 @@ class Fir2IrClassifierStorage(
        // Before the call it's not possible, because f/o binding for regular classes isn't done yet
        processMembersOfClassesOnTheFlyImmediately = true
        for ((klass, irClass) in localClassesCreatedOnTheFly) {
-            processMembersOfClassCreatedOnTheFly(klass, irClass)
+            converter.processClassMembers(klass, irClass)
            // See the problem from KT-57441
 //            class Wrapper {
 //                private val dummy = object: Bar {}
@@ -279,13 +279,6 @@ class Fir2IrClassifierStorage(
        localClassesCreatedOnTheFly.clear()
    }

-    private fun processMembersOfClassCreatedOnTheFly(klass: FirClass, irClass: IrClass) {
-        when (klass) {
-            is FirRegularClass -> converter.processRegularClassMembers(klass, irClass)
-            is FirAnonymousObject -> converter.processAnonymousObjectMembers(klass, irClass, processHeaders = false)
-        }
-    }
-
    fun processClassHeader(klass: FirClass, irClass: IrClass = getCachedIrClass(klass)!!): IrClass {
        irClass.declareTypeParameters(klass)
        irClass.setThisReceiver(klass.typeParameters)
@@ -113,10 +113,7 @@ class Fir2IrConverter(
    fun processLocalClassAndNestedClasses(klass: FirClass, parent: IrDeclarationParent): IrClass {
        val irClass = registerClassAndNestedClasses(klass, parent)
        processClassAndNestedClassHeaders(klass)
-        when (klass) {
-            is FirRegularClass -> processRegularClassMembers(klass, irClass)
-            is FirAnonymousObject -> processAnonymousObjectMembers(klass, irClass, processHeaders = false)
-        }
+        processClassMembers(klass, irClass)
        bindFakeOverridesInClass(irClass)
        return irClass
    }
@@ -171,56 +168,33 @@ class Fir2IrConverter(
        }
    }

-    // TODO: unite with/extract common part from processRegularClassMembers
-    fun processAnonymousObjectMembers(
+    fun processAnonymousObjectHeaders(
        anonymousObject: FirAnonymousObject,
        irClass: IrClass,
-        processHeaders: Boolean
-    ): IrClass {
-        if (processHeaders) {
-            registerNestedClasses(anonymousObject, irClass)
-            processNestedClassHeaders(anonymousObject)
-        }
-        anonymousObject.primaryConstructorIfAny(session)?.let {
-            irClass.declarations += declarationStorage.createIrConstructor(
-                it.fir, irClass, isLocal = true
-            )
-        }
-        for (declaration in syntheticPropertiesLast(anonymousObject.declarations)) {
-            val irDeclaration = processMemberDeclaration(declaration, anonymousObject, irClass) ?: continue
-            irClass.declarations += irDeclaration
-        }
-        // Add delegated members *before* fake override generations.
-        // Otherwise, fake overrides for delegated members, which are redundant, will be added.
-        val realDeclarations = delegatedMembers(irClass) + anonymousObject.declarations
-        with(fakeOverrideGenerator) {
-            irClass.addFakeOverrides(anonymousObject, realDeclarations)
-        }
-
-        return irClass
+    ) {
+        registerNestedClasses(anonymousObject, irClass)
+        processNestedClassHeaders(anonymousObject)
    }

-    internal fun processRegularClassMembers(
-        regularClass: FirRegularClass,
-        irClass: IrClass =
-            classifierStorage.getCachedIrClass(regularClass) ?: error("Expecting existing IrClass for class ${regularClass.name}")
-    ): IrClass {
+    internal fun processClassMembers(klass: FirClass, irClass: IrClass): IrClass {
        val allDeclarations = mutableListOf<FirDeclaration>().apply {
-            addAll(regularClass.declarations)
-            if (generatorExtensions.isNotEmpty()) {
-                addAll(regularClass.generatedMembers(session))
-                addAll(regularClass.generatedNestedClassifiers(session))
+            addAll(klass.declarations)
+            if (klass is FirRegularClass && generatorExtensions.isNotEmpty()) {
+                addAll(klass.generatedMembers(session))
+                addAll(klass.generatedNestedClassifiers(session))
            }
        }
-        val irConstructor = (allDeclarations.firstOrNull { it is FirConstructor && it.isPrimary })?.let {
-            declarationStorage.getOrCreateIrConstructor(it as FirConstructor, irClass, isLocal = regularClass.isLocal)
+        val irConstructor = klass.primaryConstructorIfAny(session)?.let {
+            declarationStorage.getOrCreateIrConstructor(
+                it.fir, irClass, isLocal = klass.isLocal
+            )
        }
        if (irConstructor != null) {
            irClass.declarations += irConstructor
        }
        // At least on enum entry creation we may need a default constructor, so ctors should be converted first
        for (declaration in syntheticPropertiesLast(allDeclarations)) {
-            val irDeclaration = processMemberDeclaration(declaration, regularClass, irClass) ?: continue
+            val irDeclaration = processMemberDeclaration(declaration, klass, irClass) ?: continue
            irClass.declarations += irDeclaration
        }
        // Add delegated members *before* fake override generations.
@@ -228,22 +202,22 @@ class Fir2IrConverter(
        allDeclarations += delegatedMembers(irClass)
        // Add synthetic members *before* fake override generations.
        // Otherwise, redundant members, e.g., synthetic toString _and_ fake override toString, will be added.
-        if (irConstructor != null && (irClass.isValue || irClass.isData)) {
+        if (klass is FirRegularClass && irConstructor != null && (irClass.isValue || irClass.isData)) {
            declarationStorage.enterScope(irConstructor)
            val dataClassMembersGenerator = DataClassMembersGenerator(components)
            if (irClass.isSingleFieldValueClass) {
-                allDeclarations += dataClassMembersGenerator.generateSingleFieldValueClassMembers(regularClass, irClass)
+                allDeclarations += dataClassMembersGenerator.generateSingleFieldValueClassMembers(klass, irClass)
            }
            if (irClass.isMultiFieldValueClass) {
-                allDeclarations += dataClassMembersGenerator.generateMultiFieldValueClassMembers(regularClass, irClass)
+                allDeclarations += dataClassMembersGenerator.generateMultiFieldValueClassMembers(klass, irClass)
            }
            if (irClass.isData) {
-                allDeclarations += dataClassMembersGenerator.generateDataClassMembers(regularClass, irClass)
+                allDeclarations += dataClassMembersGenerator.generateDataClassMembers(klass, irClass)
            }
            declarationStorage.leaveScope(irConstructor)
        }
        with(fakeOverrideGenerator) {
-            irClass.addFakeOverrides(regularClass, allDeclarations)
+            irClass.addFakeOverrides(klass, allDeclarations)
        }

        return irClass
@@ -303,7 +277,7 @@ class Fir2IrConverter(
                registerClassAndNestedClasses(it, irClass)
            }
        }
-        if (generatorExtensions.isNotEmpty()) {
+        if (klass is FirRegularClass && generatorExtensions.isNotEmpty()) {
            klass.generatedNestedClassifiers(session).forEach {
                if (it is FirRegularClass) {
                    registerClassAndNestedClasses(it, irClass)
@@ -323,7 +297,7 @@ class Fir2IrConverter(
                processClassAndNestedClassHeaders(it)
            }
        }
-        if (generatorExtensions.isNotEmpty()) {
+        if (klass is FirRegularClass && generatorExtensions.isNotEmpty()) {
            klass.generatedNestedClassifiers(session).forEach {
                if (it is FirRegularClass) {
                    processClassAndNestedClassHeaders(it)
@@ -341,7 +315,7 @@ class Fir2IrConverter(
                (containingClass !is FirRegularClass || containingClass.isLocal)
        return when (declaration) {
            is FirRegularClass -> {
-                processRegularClassMembers(declaration)
+                processClassMembers(declaration, classifierStorage.getCachedIrClass(declaration)!!)
            }
            is FirScript -> {
                parent as IrFile
@@ -138,7 +138,8 @@ class Fir2IrVisitor(
            declarationStorage.enterScope(irEnumEntry)
            classifierStorage.putEnumEntryClassInScope(enumEntry, correspondingClass)
            val anonymousObject = (enumEntry.initializer as FirAnonymousObjectExpression).anonymousObject
-            converter.processAnonymousObjectMembers(anonymousObject, correspondingClass, processHeaders = true)
+            converter.processAnonymousObjectHeaders(anonymousObject, correspondingClass)
+            converter.processClassMembers(anonymousObject, correspondingClass)
            converter.bindFakeOverridesInClass(correspondingClass)
            conversionScope.withParent(correspondingClass) {
                memberGenerator.convertClassContent(correspondingClass, anonymousObject)
@@ -59,7 +59,7 @@ internal class ClassMemberGenerator(
        conversionScope.withClass(irClass) {
            val allDeclarations = buildList {
                addAll(klass.declarations)
-                if (session.extensionService.declarationGenerators.isNotEmpty()) {
+                if (klass is FirRegularClass && session.extensionService.declarationGenerators.isNotEmpty()) {
                    addAll(klass.generatedMembers(session).sortedWith(FirCallableDeclarationComparator))
                    addAll(klass.generatedNestedClassifiers(session).sortedWith(FirMemberDeclarationComparator))
                }
@@ -7,13 +7,13 @@ package org.jetbrains.kotlin.fir.extensions

 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration
-import org.jetbrains.kotlin.fir.declarations.FirClass
 import org.jetbrains.kotlin.fir.declarations.FirClassLikeDeclaration
+import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 import org.jetbrains.kotlin.fir.scopes.impl.declaredMemberScope
 import org.jetbrains.kotlin.fir.scopes.processClassifiersByName
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol

-fun FirClass.generatedNestedClassifiers(session: FirSession): List<FirClassLikeDeclaration> {
+fun FirRegularClass.generatedNestedClassifiers(session: FirSession): List<FirClassLikeDeclaration> {
    val scope = session.declaredMemberScope(this, memberRequiredPhase = null)
    val result = mutableListOf<FirClassLikeDeclaration>()
    for (name in scope.getClassifierNames()) {
@@ -28,7 +28,7 @@ fun FirClass.generatedNestedClassifiers(session: FirSession): List<FirClassLikeD
    return result
 }

-fun FirClass.generatedMembers(session: FirSession): List<FirCallableDeclaration> {
+fun FirRegularClass.generatedMembers(session: FirSession): List<FirCallableDeclaration> {
    val scope = session.declaredMemberScope(this, memberRequiredPhase = null)
    val result = mutableListOf<FirCallableDeclaration>()
    for (name in scope.getCallableNames()) {