JS: fix translation of lambdas in public inline functions; fix AMD emulation for Ant test

js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/LiteralFunctionTranslator.kt

@@ -62,25 +62,25 @@ class LiteralFunctionTranslator(context: TranslationContext) : AbstractTranslato
             tracker.getNameForCapturedDescriptor(descriptor)
         }
         else {
-            context().getInnerNameForDescriptor(descriptor)
+            invokingContext.getInnerNameForDescriptor(descriptor)
         }
 
         if (tracker.hasCapturedExceptContaining()) {
             val lambdaCreator = simpleReturnFunction(invokingContext.scope(), lambda)
-            lambdaCreator.name = context().getInnerNameForDescriptor(descriptor)
+            lambdaCreator.name = invokingContext.getInnerNameForDescriptor(descriptor)
             lambdaCreator.isLocal = true
             if (!isRecursive) {
                 lambda.name = null
             }
             lambdaCreator.name.staticRef = lambdaCreator
-            return lambdaCreator.withCapturedParameters(functionContext, invokingContext)
+            return lambdaCreator.withCapturedParameters(descriptor, functionContext, invokingContext)
         }
 
         lambda.isLocal = true
 
-        context().addDeclarationStatement(lambda.makeStmt())
+        invokingContext.addDeclarationStatement(lambda.makeStmt())
         lambda.name.staticRef = lambda
-        return lambda.name.makeRef().apply { sideEffects = SideEffectKind.PURE }
+        return getReferenceToLambda(invokingContext, descriptor, lambda.name)
     }
 
     fun ValueParameterDescriptorImpl.WithDestructuringDeclaration.translate(context: TranslationContext): JsVars {
@@ -93,9 +93,13 @@ class LiteralFunctionTranslator(context: TranslationContext) : AbstractTranslato
     }
 }
 
-fun JsFunction.withCapturedParameters(context: TranslationContext, invokingContext: TranslationContext): JsExpression {
+fun JsFunction.withCapturedParameters(
+        descriptor: CallableMemberDescriptor,
+        context: TranslationContext,
+        invokingContext: TranslationContext
+): JsExpression {
     context.addDeclarationStatement(makeStmt())
-    val ref = name.makeRef().apply { sideEffects = SideEffectKind.PURE }
+    val ref = getReferenceToLambda(invokingContext, descriptor, name)
     val invocation = JsInvocation(ref).apply { sideEffects = SideEffectKind.PURE }
 
     val invocationArguments = invocation.arguments
@@ -128,6 +132,19 @@ fun JsFunction.withCapturedParameters(context: TranslationContext, invokingConte
     return invocation
 }
 
+private fun getReferenceToLambda(context: TranslationContext, descriptor: CallableMemberDescriptor, name: JsName): JsExpression {
+    return if (context.isPublicInlineFunction) {
+        val fqn = context.getQualifiedReference(descriptor)
+        if (fqn is JsNameRef) {
+            fqn.name?.let { it.staticRef = name.staticRef }
+        }
+        fqn
+    }
+    else {
+        JsAstUtils.pureFqn(name, null)
+    }
+}
+
 private data class CapturedArgsParams(val arguments: List<JsExpression> = listOf(), val parameters: List<JsParameter> = listOf())
 
 /**

js/js.translator/testData/box/crossModuleRef/lambda.kt

@@ -0,0 +1,17 @@
+// MODULE: lib
+// FILE: lib.kt
+package lib
+
+fun bar(f: () -> String) = f()
+
+inline fun foo(): String {
+    return bar { "OK" }
+}
+
+// MODULE: main(lib)
+// FILE: main.kt
+package main
+
+import lib.*
+
+fun box() = foo()