Add tests

model/inline/src/test/scala/aqua/model/inline/ArrowInlinerSpec.scala

@@ -656,10 +656,8 @@ class ArrowInlinerSpec extends AnyFlatSpec with Matchers {
       ScalarType.u16
     )
 
-    val (closureFunc, closureType, closureTypeLabelled) = addClosure(
-      closureName,
-      innerArg
-    )
+    val (closureFunc, closureType, closureTypeLabelled) =
+      addClosure(closureName, innerArg)
 
     val innerRes = VarRaw(
       closureName,
@@ -1140,6 +1138,129 @@ class ArrowInlinerSpec extends AnyFlatSpec with Matchers {
     model.equalsOrShowDiff(expected) shouldEqual true
   }
 
+  /**
+   * func accept_closure(closure: u16 -> u16) -> u16:
+   *   resA <- closure(42)
+   *   <- resA
+   *
+   * func test() -> u16:
+   *   closure = (x: u16) -> u16:
+   *     resC = x + 37
+   *     <- resC
+   *   resT <- accept_closure(closure)
+   *   <- resT
+   */
+  "arrow inliner" should "correctly handle closure as argument [bug LNG-92]" in {
+    val acceptName = "accept_closure"
+    val closureName = "closure"
+    val testName = "test"
+    val acceptRes = VarRaw("resA", ScalarType.u16)
+    val testRes = VarRaw("resT", ScalarType.u16)
+
+    val (closureFunc, closureType, closureTypeLabelled) =
+      addClosure(closureName, LiteralRaw("37", LiteralType.number))
+
+    val acceptType = ArrowType(
+      domain = ProductType.labelled(List(closureName -> closureType)),
+      codomain = ProductType(ScalarType.u16 :: Nil)
+    )
+
+    val acceptBody = SeqTag.wrap(
+      CallArrowRawTag(
+        List(Call.Export(acceptRes.name, acceptRes.baseType)),
+        CallArrowRaw(
+          ability = None,
+          name = closureName,
+          arguments = List(LiteralRaw("42", LiteralType.number)),
+          baseType = closureType,
+          serviceId = None
+        )
+      ).leaf,
+      ReturnTag(
+        NonEmptyList.one(acceptRes)
+      ).leaf
+    )
+
+    val acceptFunc = FuncArrow(
+      funcName = acceptName,
+      body = acceptBody,
+      arrowType = ArrowType(
+        ProductType.labelled(List(closureName -> closureType)),
+        ProductType(List(ScalarType.u16))
+      ),
+      ret = List(acceptRes),
+      capturedArrows = Map.empty,
+      capturedValues = Map.empty,
+      capturedTopology = None
+    )
+
+    val testBody = SeqTag.wrap(
+      ClosureTag(
+        func = closureFunc,
+        detach = false
+      ).leaf,
+      CallArrowRawTag(
+        List(Call.Export(testRes.name, testRes.baseType)),
+        CallArrowRaw(
+          ability = None,
+          name = acceptName,
+          arguments = List(VarRaw(closureName, closureTypeLabelled)),
+          baseType = acceptFunc.arrowType,
+          serviceId = None
+        )
+      ).leaf,
+      ReturnTag(
+        NonEmptyList.one(testRes)
+      ).leaf
+    )
+
+    val testFunc = FuncArrow(
+      funcName = testName,
+      body = testBody,
+      arrowType = ArrowType(
+        ProductType(Nil),
+        ProductType(List(ScalarType.u16))
+      ),
+      ret = List(testRes),
+      capturedArrows = Map(acceptName -> acceptFunc),
+      capturedValues = Map.empty,
+      capturedTopology = None
+    )
+
+    val model = ArrowInliner
+      .callArrow[InliningState](
+        testFunc,
+        CallModel(Nil, Nil)
+      )
+      .runA(InliningState())
+      .value
+
+    /* WARNING: This naming is unstable */
+    val tempAdd = VarModel("add", ScalarType.u16)
+
+    val expected = SeqModel.wrap(
+      CaptureTopologyModel(closureName).leaf,
+      MetaModel
+        .CallArrowModel(acceptName)
+        .wrap(
+          MetaModel
+            .CallArrowModel(closureName)
+            .wrap(
+              ApplyTopologyModel(closureName).wrap(
+                ModelBuilder
+                  .add(
+                    LiteralModel("42", LiteralType.number),
+                    LiteralModel("37", LiteralType.number)
+                  )(tempAdd)
+                  .leaf
+              )
+            )
+        )
+    )
+
+    model.equalsOrShowDiff(expected) shouldEqual true
+  }
+
   /*
    data Prod:
      value: string