Simplify ExternalDependenciesGenerator

Remove unused parameters, inline inner class

compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/compiler.kt

@@ -172,7 +172,7 @@ fun compile(
 
     val context = if (compileMode.generateKlib) {
         deserializedModuleFragments.forEach {
-            ExternalDependenciesGenerator(it.descriptor, symbolTable, irBuiltIns).generateUnboundSymbolsAsDependencies(it)
+            ExternalDependenciesGenerator(it.descriptor, symbolTable, irBuiltIns).generateUnboundSymbolsAsDependencies()
         }
         deserializedModuleFragments.forEach { it.patchDeclarationParents() }
         serializeModuleIntoKlib(
@@ -216,7 +216,7 @@ fun compile(
                 context.symbolTable,
                 context.irBuiltIns,
                 deserializer = deserializer
-            ).generateUnboundSymbolsAsDependencies(it)
+            ).generateUnboundSymbolsAsDependencies()
         }
 
         // TODO: check the order
@@ -229,10 +229,9 @@ fun compile(
             moduleDescriptor = context.module,
             symbolTable = context.symbolTable,
             irBuiltIns = context.irBuiltIns
-        ).generateUnboundSymbolsAsDependencies(moduleFragment)
+        ).generateUnboundSymbolsAsDependencies()
         moduleFragment.patchDeclarationParents()
 
-
         jsPhases.invokeToplevel(context.phaseConfig, context, moduleFragment)
 
         moduleFragment.accept(IrModuleToJsTransformer(context), null)

compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/inline/IrUnboundSymbolReplacer.kt

@@ -58,7 +58,7 @@ internal fun IrModuleFragment.replaceUnboundSymbols(context: JsIrBackendContext)
         descriptor,
         symbolTable = context.symbolTable,
         irBuiltIns = context.irBuiltIns
-    ).generateUnboundSymbolsAsDependencies(this)
+    ).generateUnboundSymbolsAsDependencies()
 }
 
 private class DeclarationSymbolCollector : IrElementVisitorVoid {

compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmBackendFacade.kt

@@ -23,13 +23,13 @@ object JvmBackendFacade {
     }
 
     internal fun doGenerateFilesInternal(
-            state: GenerationState,
-            errorHandler: CompilationErrorHandler,
-            irModuleFragment: IrModuleFragment,
-            psi2irContext: GeneratorContext
+        state: GenerationState,
+        errorHandler: CompilationErrorHandler,
+        irModuleFragment: IrModuleFragment,
+        psi2irContext: GeneratorContext
     ) {
         val jvmBackendContext = JvmBackendContext(
-                state, psi2irContext.sourceManager, psi2irContext.irBuiltIns, irModuleFragment, psi2irContext.symbolTable
+            state, psi2irContext.sourceManager, psi2irContext.irBuiltIns, irModuleFragment, psi2irContext.symbolTable
         )
         //TODO
         ExternalDependenciesGenerator(
@@ -37,7 +37,7 @@ object JvmBackendFacade {
             psi2irContext.symbolTable,
             psi2irContext.irBuiltIns,
             JvmGeneratorExtensions.externalDeclarationOrigin
-        ).generateUnboundSymbolsAsDependencies(irModuleFragment)
+        ).generateUnboundSymbolsAsDependencies()
 
         val jvmBackend = JvmBackend(jvmBackendContext)
 
@@ -45,11 +45,9 @@ object JvmBackendFacade {
             try {
                 jvmBackend.generateFile(irFile)
                 state.afterIndependentPart()
-            }
-            catch (e: Throwable) {
+            } catch (e: Throwable) {
                 errorHandler.reportException(e, null) // TODO ktFile.virtualFile.url
             }
         }
     }
-
 }

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/ModuleGenerator.kt

@@ -45,7 +45,7 @@ class ModuleGenerator(override val context: GeneratorContext) : Generator {
     fun generateUnboundSymbolsAsDependencies(irModule: IrModuleFragment, deserializer: IrDeserializer? = null) {
         ExternalDependenciesGenerator(
             irModule.descriptor, context.symbolTable, context.irBuiltIns, context.extensions.externalDeclarationOrigin, deserializer
-        ).generateUnboundSymbolsAsDependencies(irModule, context.bindingContext)
+        ).generateUnboundSymbolsAsDependencies()
     }
 
     private fun generateFiles(ktFiles: Collection<KtFile>): List<IrFile> {

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/lazy/IrLazyProperty.kt

@@ -64,7 +64,7 @@ class IrLazyProperty(
 
     override var backingField: IrField? by lazyVar {
         if (descriptor.hasBackingField(bindingContext)) {
-            stubGenerator.generateFieldStub(descriptor, bindingContext).apply {
+            stubGenerator.generateFieldStub(descriptor).apply {
                 correspondingProperty = this@IrLazyProperty
             }
         } else null
@@ -94,4 +94,4 @@ class IrLazyProperty(
         getter = getter?.run { transform(transformer, data) as IrSimpleFunction }
         setter = setter?.run { transform(transformer, data) as IrSimpleFunction }
     }
-}
+}

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DeclarationStubGenerator.kt

@@ -90,7 +90,7 @@ class DeclarationStubGenerator(
         )
     }
 
-    fun generateFieldStub(descriptor: PropertyDescriptor, bindingContext: BindingContext? = null): IrField {
+    fun generateFieldStub(descriptor: PropertyDescriptor): IrField {
         val referenced = symbolTable.referenceField(descriptor)
         if (referenced.isBound) {
             return referenced.owner

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/ExternalDependenciesGenerator.kt

@@ -19,58 +19,49 @@ package org.jetbrains.kotlin.ir.util
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin
-import org.jetbrains.kotlin.ir.declarations.IrModuleFragment
 import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
-import org.jetbrains.kotlin.resolve.BindingContext
 
 class ExternalDependenciesGenerator(
     moduleDescriptor: ModuleDescriptor,
     val symbolTable: SymbolTable,
     val irBuiltIns: IrBuiltIns,
     externalDeclarationOrigin: ((DeclarationDescriptor) -> IrDeclarationOrigin)? = null,
-    val deserializer: IrDeserializer? = null
+    private val deserializer: IrDeserializer? = null
 ) {
     private val stubGenerator = DeclarationStubGenerator(
         moduleDescriptor, symbolTable, irBuiltIns.languageVersionSettings, externalDeclarationOrigin, deserializer
     )
 
-    fun generateUnboundSymbolsAsDependencies(irModule: IrModuleFragment, bindingContext: BindingContext? = null) {
-        DependencyGenerationTask(irModule, bindingContext).run()
-    }
-
-    private inner class DependencyGenerationTask(val irModule: IrModuleFragment, val bindingContext: BindingContext?) {
-
-        fun run() {
-            stubGenerator.unboundSymbolGeneration = true
-            ArrayList(symbolTable.unboundClasses).forEach {
-                stubGenerator.generateClassStub(it.descriptor)
-            }
-            ArrayList(symbolTable.unboundConstructors).forEach {
-                stubGenerator.generateConstructorStub(it.descriptor)
-            }
-            ArrayList(symbolTable.unboundEnumEntries).forEach {
-                stubGenerator.generateEnumEntryStub(it.descriptor)
-            }
-            ArrayList(symbolTable.unboundFields).forEach {
-                stubGenerator.generateFieldStub(it.descriptor, bindingContext)
-            }
-            ArrayList(symbolTable.unboundSimpleFunctions).forEach {
-                stubGenerator.generateFunctionStub(it.descriptor)
-            }
-            ArrayList(symbolTable.unboundTypeParameters).forEach {
-                stubGenerator.generateOrGetTypeParameterStub(it.descriptor)
-            }
-
-            deserializer?.declareForwardDeclarations()
-
-            if (deserializer != null) return
-
-            assert(symbolTable.unboundClasses.isEmpty())
-            assert(symbolTable.unboundConstructors.isEmpty())
-            assert(symbolTable.unboundEnumEntries.isEmpty())
-            assert(symbolTable.unboundFields.isEmpty())
-            assert(symbolTable.unboundSimpleFunctions.isEmpty())
-            assert(symbolTable.unboundTypeParameters.isEmpty())
+    fun generateUnboundSymbolsAsDependencies() {
+        stubGenerator.unboundSymbolGeneration = true
+        ArrayList(symbolTable.unboundClasses).forEach {
+            stubGenerator.generateClassStub(it.descriptor)
         }
+        ArrayList(symbolTable.unboundConstructors).forEach {
+            stubGenerator.generateConstructorStub(it.descriptor)
+        }
+        ArrayList(symbolTable.unboundEnumEntries).forEach {
+            stubGenerator.generateEnumEntryStub(it.descriptor)
+        }
+        ArrayList(symbolTable.unboundFields).forEach {
+            stubGenerator.generateFieldStub(it.descriptor)
+        }
+        ArrayList(symbolTable.unboundSimpleFunctions).forEach {
+            stubGenerator.generateFunctionStub(it.descriptor)
+        }
+        ArrayList(symbolTable.unboundTypeParameters).forEach {
+            stubGenerator.generateOrGetTypeParameterStub(it.descriptor)
+        }
+
+        deserializer?.declareForwardDeclarations()
+
+        if (deserializer != null) return
+
+        assert(symbolTable.unboundClasses.isEmpty())
+        assert(symbolTable.unboundConstructors.isEmpty())
+        assert(symbolTable.unboundEnumEntries.isEmpty())
+        assert(symbolTable.unboundFields.isEmpty())
+        assert(symbolTable.unboundSimpleFunctions.isEmpty())
+        assert(symbolTable.unboundTypeParameters.isEmpty())
     }
 }