Compile zero-args to LLVM IR

1 files changed, 45 insertions, 3 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 45af4ac3..1088f87f 100644
--- a/src/test/java/org/shedlang/compiler/backends/llvm/LlvmCompilerCallTests.java
+++ b/src/test/java/org/shedlang/compiler/backends/llvm/LlvmCompilerCallTests.java
@@ -3,11 +3,15 @@ package org.shedlang.compiler.backends.llvm;
 import org.junit.jupiter.api.Test;
 import org.shedlang.compiler.backends.llvm.ir.ast.LlvmIr;
 import org.shedlang.compiler.backends.llvm.ir.ast.instructions.LlvmCall;
+import org.shedlang.compiler.backends.llvm.ir.ast.instructions.LlvmGetElementPtr;
+import org.shedlang.compiler.backends.llvm.ir.ast.instructions.LlvmIntToPtr;
+import org.shedlang.compiler.backends.llvm.ir.ast.instructions.LlvmLoad;
+import org.shedlang.compiler.backends.llvm.ir.ast.types.LlvmTypes;
 import org.shedlang.compiler.stackir.instructions.Instructions;
 
 import java.util.List;
 
-import static org.shedlang.compiler.backends.llvm.ir.ast.LlvmIrMatchers.isLlvmVariableLocal;
+import static org.shedlang.compiler.backends.llvm.ir.ast.LlvmIrMatchers.*;
 import static org.zwobble.precisely.AssertThat.assertThat;
 import static org.zwobble.precisely.Matchers.*;
 
@@ -23,11 +27,49 @@ public class LlvmCompilerCallTests {
 
         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("f")),
-                has("args", x -> x.args(), isSequence())
+                has("functionPointer", x -> x.functionPointer(), isLlvmVariableLocal("closureFunctionPointer__0")),
+                has("args", x -> x.args(), isSequence(
+                    isLlvmTypedOperand(
+                        LlvmCompilerClosures.typeClosureEnvironmentPointer(),
+                        isLlvmVariableLocal("closureEnvironmentPointer__0")
+                    )
+                ))
             )
         ));
         assertThat(result.stack(), isSequence(