Include args when compiling call to LLVM IR

1 files changed, 70 insertions, 0 deletions

diff --git a/src/test/java/org/shedlang/compiler/backends/llvm/LlvmCompilerCallTests.java b/src/test/java/org/shedlang/compiler/backends/llvm/LlvmCompilerCallTests.java
index 1088f87f..428c9d5d 100644
--- a/src/test/java/org/shedlang/compiler/backends/llvm/LlvmCompilerCallTests.java
+++ b/src/test/java/org/shedlang/compiler/backends/llvm/LlvmCompilerCallTests.java
@@ -77,4 +77,74 @@ public class LlvmCompilerCallTests {
             isLlvmVariableLocal("x")
         ));
     }
+
+    @Test
+    public void canCallFunctionWithArgs() {
+        var instruction = Instructions.call(2, List.of("b", "a"));
+        var context = LlvmCompilerContext.EMPTY
+            .push(LlvmIr.variableLocal("x"))
+            .push(LlvmIr.variableLocal("f"))
+            .push(LlvmIr.variableLocal("positional1"))
+            .push(LlvmIr.variableLocal("positional2"))
+            .push(LlvmIr.variableLocal("namedB"))
+            .push(LlvmIr.variableLocal("namedA"));
+
+        var result = LlvmCompiler.compileInstruction(instruction, context);
+
+        assertThat(result.instructions(), isSequence(
+            instanceOf(
+                LlvmIntToPtr.class,
+                has("target", x -> x.target(), isLlvmVariableLocal("closurePointer__0")),
+                has("sourceType", x -> x.sourceType(), equalTo(LlvmCompilerTypes.VALUE_TYPE)),
+                has("value", x -> x.value(), isLlvmVariableLocal("f")),
+                has("targetType", x -> x.targetType(), equalTo(LlvmCompilerClosures.typeClosurePointer()))
+            ),
+            instanceOf(
+                LlvmGetElementPtr.class,
+                has("target", x -> x.target(), isLlvmVariableLocal("closureFunctionPointerPointer__0")),
+                has("pointerType", x -> x.pointerType(), equalTo(LlvmCompilerClosures.typeClosurePointer())),
+                has("pointer", x -> x.pointer(), isLlvmVariableLocal("closurePointer__0")),
+                has("indexes", x -> x.indexes(), isSequence(
+                    isLlvmTypedOperand(LlvmTypes.INT_64, isLlvmOperandInt(0)),
+                    isLlvmTypedOperand(LlvmTypes.INT_32, isLlvmOperandInt(0))
+                ))
+            ),
+            instanceOf(
+                LlvmLoad.class,
+                has("target", x -> x.target(), isLlvmVariableLocal("closureFunctionPointer__0")),
+                has("type", x -> x.type(), equalTo(LlvmCompilerClosures.typeClosureFunctionPointer())),
+                has("pointer", x -> x.pointer(), isLlvmVariableLocal("closureFunctionPointerPointer__0"))
+            ),
+            instanceOf(
+                LlvmGetElementPtr.class,
+                has("target", x -> x.target(), isLlvmVariableLocal("closureEnvironmentPointer__0")),
+                has("pointerType", x -> x.pointerType(), equalTo(LlvmCompilerClosures.typeClosurePointer())),
+                has("pointer", x -> x.pointer(), isLlvmVariableLocal("closurePointer__0")),
+                has("indexes", x -> x.indexes(), isSequence(
+                    isLlvmTypedOperand(LlvmTypes.INT_64, isLlvmOperandInt(0)),
+                    isLlvmTypedOperand(LlvmTypes.INT_32, isLlvmOperandInt(1))
+                ))
+            ),
+            instanceOf(
+                LlvmCall.class,
+                has("target", x -> x.target(), isLlvmVariableLocal("tmp__0")),
+                has("returnType", x -> x.returnType(), equalTo(LlvmCompilerTypes.VALUE_TYPE)),
+                has("functionPointer", x -> x.functionPointer(), isLlvmVariableLocal("closureFunctionPointer__0")),
+                has("args", x -> x.args(), isSequence(
+                    isLlvmTypedOperand(
+                        LlvmCompilerClosures.typeClosureEnvironmentPointer(),
+                        isLlvmVariableLocal("closureEnvironmentPointer__0")
+                    ),
+                    isLlvmTypedOperand(LlvmCompilerTypes.VALUE_TYPE, isLlvmVariableLocal("positional1")),
+                    isLlvmTypedOperand(LlvmCompilerTypes.VALUE_TYPE, isLlvmVariableLocal("positional2")),
+                    isLlvmTypedOperand(LlvmCompilerTypes.VALUE_TYPE, isLlvmVariableLocal("namedA")),
+                    isLlvmTypedOperand(LlvmCompilerTypes.VALUE_TYPE, isLlvmVariableLocal("namedB"))
+                ))
+            )
+        ));
+        assertThat(result.stack(), isSequence(
+            isLlvmVariableLocal("tmp__0"),
+            isLlvmVariableLocal("x")
+        ));
+    }
 }