Prototyping DCE tool for JS

js/js.inliner/src/org/jetbrains/kotlin/js/inline/FunctionReader.kt

@@ -57,7 +57,7 @@ class FunctionReader(private val config: JsConfig, private val currentModuleName
      * kotlinVariable: kotlin object variable.
      *     The default variable is Kotlin, but it can be renamed by minifier.
      */
-    data class ModuleInfo(val fileContent: String, val moduleVariable: String, val kotlinVariable: String)
+    data class ModuleInfo(val filePath: String, val fileContent: String, val moduleVariable: String, val kotlinVariable: String)
 
     private val moduleNameToInfo = HashMultimap.create<String, ModuleInfo>()
 
@@ -68,7 +68,7 @@ class FunctionReader(private val config: JsConfig, private val currentModuleName
 
         moduleNameMap = buildModuleNameMap(fragments)
 
-        JsLibraryUtils.traverseJsLibraries(libs) { fileContent, _ ->
+        JsLibraryUtils.traverseJsLibraries(libs) { fileContent, filePath ->
             var current = 0
 
             while (true) {
@@ -83,7 +83,7 @@ class FunctionReader(private val config: JsConfig, private val currentModuleName
                 val moduleName = preciseMatcher.group(3)
                 val moduleVariable = preciseMatcher.group(4)
                 val kotlinVariable = preciseMatcher.group(1)
-                moduleNameToInfo.put(moduleName, ModuleInfo(fileContent, moduleVariable, kotlinVariable))
+                moduleNameToInfo.put(moduleName, ModuleInfo(filePath, fileContent, moduleVariable, kotlinVariable))
             }
         }
     }
@@ -152,7 +152,7 @@ class FunctionReader(private val config: JsConfig, private val currentModuleName
             offset++
         }
 
-        val function = parseFunction(source, offset, ThrowExceptionOnErrorReporter, JsRootScope(JsProgram()))
+        val function = parseFunction(source, info.filePath, offset, ThrowExceptionOnErrorReporter, JsRootScope(JsProgram()))
         val moduleReference = moduleNameMap[tag] ?: currentModuleName.makeRef()
 
         val replacements = hashMapOf(info.moduleVariable to moduleReference,

js/js.inliner/src/org/jetbrains/kotlin/js/inline/util/fixForwardNameReferences.kt

@@ -0,0 +1,79 @@
+/*
+ * Copyright 2010-2017 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.js.inline.util
+
+import org.jetbrains.kotlin.js.backend.ast.*
+
+fun JsNode.fixForwardNameReferences() {
+    accept(object : RecursiveJsVisitor() {
+        val currentScope = mutableMapOf<String, JsName>()
+
+        init {
+            currentScope += collectDefinedNames(this@fixForwardNameReferences).associateBy { it.ident }
+        }
+
+        override fun visitFunction(x: JsFunction) {
+            val scopeBackup = mutableMapOf<String, JsName?>()
+            val localVars = x.collectLocalVariables()
+            for (localVar in localVars) {
+                scopeBackup[localVar.ident] = currentScope[localVar.ident]
+                currentScope[localVar.ident] = localVar
+            }
+
+            super.visitFunction(x)
+
+            for ((ident, oldName) in scopeBackup) {
+                if (oldName == null) {
+                    currentScope -= ident
+                }
+                else {
+                    currentScope[ident] = oldName
+                }
+            }
+        }
+
+        override fun visitCatch(x: JsCatch) {
+            val name = x.parameter.name
+            val oldName = currentScope[name.ident]
+            currentScope[name.ident] = name
+
+            super.visitCatch(x)
+
+            if (oldName != null) {
+                currentScope[name.ident] = name
+            }
+            else {
+                currentScope -= name.ident
+            }
+        }
+
+        override fun visitNameRef(nameRef: JsNameRef) {
+            super.visitNameRef(nameRef)
+            if (nameRef.qualifier == null) {
+                val ident = nameRef.ident
+                val name = currentScope[ident]
+                if (name != null) {
+                    nameRef.name = name
+                }
+            }
+        }
+
+        override fun visitBreak(x: JsBreak) {}
+
+        override fun visitContinue(x: JsContinue) {}
+    })
+}