Fix tests: "Placing function type parameters after the function name" error

js/js.translator/testData/inline/cases/expressionBodyWithLambdaCall.kt

@@ -5,7 +5,7 @@ package foo
 // A copy of stdlib run function.
 // Copied to not to depend on run implementation.
 // It's important, that the body is just `return fn()`.
-internal inline fun evaluate<T>(fn: ()->T): T = fn()
+internal inline fun <T> evaluate(fn: ()->T): T = fn()
 
 internal fun test(n: Int): Int {
     return evaluate {

js/js.translator/testData/inline/cases/lambdaInLambda.kt

@@ -4,7 +4,7 @@ package foo
 // CHECK_NOT_CALLED_IN_SCOPE: scope=multiplyBy2 function=multiplyBy2$f_0
 // CHECK_NOT_CALLED_IN_SCOPE: scope=multiplyBy2 function=run
 
-internal inline fun runLambdaInLambda<T>(noinline inner: (T) -> T, outer: ((T) -> T, T) -> T, arg: T): T {
+internal inline fun <T> runLambdaInLambda(noinline inner: (T) -> T, outer: ((T) -> T, T) -> T, arg: T): T {
     return outer(inner, arg)
 }
 

js/js.translator/testData/inline/cases/metadataForPublicFunction.kt

@@ -12,27 +12,27 @@ package foo
 // CHECK_HAS_NO_INLINE_METADATA: applyO_hiyix$
 
 inline
-public fun apply<T>(arg: T, func: (T)->T): T = func(arg)
+public fun <T> apply(arg: T, func: (T)->T): T = func(arg)
 
 public open class L {
     inline
-    protected fun applyL<T>(arg: T, func: (T)->T): T = func(arg)
+    protected fun <T> applyL(arg: T, func: (T)->T): T = func(arg)
 }
 
 public class M {
     inline
-    public fun applyM<T>(arg: T, func: (T)->T): T = func(arg)
+    public fun <T> applyM(arg: T, func: (T)->T): T = func(arg)
 }
 
 internal class N {
     inline
-    public fun applyN<T>(arg: T, func: (T)->T): T = func(arg)
+    public fun <T> applyN(arg: T, func: (T)->T): T = func(arg)
 }
 
 private object O {
     public object OInner {
         inline
-        public fun applyO<T>(arg: T, func: (T)->T): T = func(arg)
+        public fun <T> applyO(arg: T, func: (T)->T): T = func(arg)
     }
 }
 

js/js.translator/testData/inline/cases/noInlineLambda.kt

@@ -3,7 +3,7 @@ package foo
 // CHECK_CALLED_IN_SCOPE: scope=multiplyBy2 function=multiplyBy2$f
 // CHECK_NOT_CALLED_IN_SCOPE: scope=multiplyBy2 function=run
 
-internal inline fun run<T>(noinline func: (T) -> T, arg: T): T {
+internal inline fun <T> run(noinline func: (T) -> T, arg: T): T {
     return func(arg)
 }