Rename LlvmCompiler to LlvmCodeGen

11 files changed, 54 insertions, 54 deletions

diff --git a/src/test/java/org/shedlang/compiler/backends/llvm/LlvmCompilerCallTests.java b/src/test/java/org/shedlang/compiler/backends/llvm/LlvmCodeGenCallTests.java
index f43c7bf6..a5c56a7b 100644
--- a/src/test/java/org/shedlang/compiler/backends/llvm/LlvmCompilerCallTests.java
+++ b/src/test/java/org/shedlang/compiler/backends/llvm/LlvmCodeGenCallTests.java
@@ -15,27 +15,27 @@ import static org.shedlang.compiler.backends.llvm.ir.ast.LlvmIrMatchers.*;
 import static org.zwobble.precisely.AssertThat.assertThat;
 import static org.zwobble.precisely.Matchers.*;
 
-public class LlvmCompilerCallTests {
+public class LlvmCodeGenCallTests {
     @Test
     public void canCallFunctionWithNoArgs() {
         var instruction = Instructions.call(0, List.of());
-        var context = LlvmCompilerContext.EMPTY
+        var context = LlvmCodeGenContext.EMPTY
             .push(LlvmIr.variableLocal("x"))
             .push(LlvmIr.variableLocal("f"));
 
-        var result = LlvmCompiler.compileInstruction(instruction, context);
+        var result = LlvmCodeGen.generateInstruction(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("sourceType", x -> x.sourceType(), equalTo(LlvmCodeGenTypes.VALUE_TYPE)),
                 has("value", x -> x.value(), isLlvmVariableLocal("f"))
             ),
             instanceOf(
                 LlvmGetElementPtr.class,
                 has("target", x -> x.target(), isLlvmVariableLocal("closureFunctionPointerPointer__0")),
-                has("pointerType", x -> x.pointerType(), equalTo(LlvmCompilerClosures.CALLABLE_TYPES.closurePointer())),
+                has("pointerType", x -> x.pointerType(), equalTo(LlvmCodeGenClosures.CALLABLE_TYPES.closurePointer())),
                 has("pointer", x -> x.pointer(), isLlvmVariableLocal("closurePointer__0")),
                 has("indexes", x -> x.indexes(), isSequence(
                     isLlvmTypedOperand(LlvmTypes.INT_64, isLlvmOperandInt(0)),
@@ -45,17 +45,17 @@ public class LlvmCompilerCallTests {
             instanceOf(
                 LlvmLoad.class,
                 has("target", x -> x.target(), isLlvmVariableLocal("closureFunctionPointer__0")),
-                has("type", x -> x.type(), equalTo(LlvmCompilerClosures.CALLABLE_TYPES.closureFunctionPointer())),
+                has("type", x -> x.type(), equalTo(LlvmCodeGenClosures.CALLABLE_TYPES.closureFunctionPointer())),
                 has("pointer", x -> x.pointer(), isLlvmVariableLocal("closureFunctionPointerPointer__0"))
             ),
             instanceOf(
                 LlvmCall.class,
                 has("target", x -> x.target(), isOptionalOf(isLlvmVariableLocal("tmp__0"))),
-                has("returnType", x -> x.returnType(), equalTo(LlvmCompilerTypes.VALUE_TYPE)),
+                has("returnType", x -> x.returnType(), equalTo(LlvmCodeGenTypes.VALUE_TYPE)),
                 has("functionPointer", x -> x.functionPointer(), isLlvmVariableLocal("closureFunctionPointer__0")),
                 has("args", x -> x.args(), isSequence(
                     isLlvmTypedOperand(
-                        LlvmCompilerClosures.CALLABLE_TYPES.closurePointer(),
+                        LlvmCodeGenClosures.CALLABLE_TYPES.closurePointer(),
                         isLlvmVariableLocal("closurePointer__0")
                     )
                 ))
@@ -70,7 +70,7 @@ public class LlvmCompilerCallTests {
     @Test
     public void canCallFunctionWithArgs() {
         var instruction = Instructions.call(2, List.of("b", "a"));
-        var context = LlvmCompilerContext.EMPTY
+        var context = LlvmCodeGenContext.EMPTY
             .push(LlvmIr.variableLocal("x"))
             .push(LlvmIr.variableLocal("f"))
             .push(LlvmIr.variableLocal("positional1"))
@@ -78,19 +78,19 @@ public class LlvmCompilerCallTests {
             .push(LlvmIr.variableLocal("namedB"))
             .push(LlvmIr.variableLocal("namedA"));
 
-        var result = LlvmCompiler.compileInstruction(instruction, context);
+        var result = LlvmCodeGen.generateInstruction(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("sourceType", x -> x.sourceType(), equalTo(LlvmCodeGenTypes.VALUE_TYPE)),
                 has("value", x -> x.value(), isLlvmVariableLocal("f"))
             ),
             instanceOf(
                 LlvmGetElementPtr.class,
                 has("target", x -> x.target(), isLlvmVariableLocal("closureFunctionPointerPointer__0")),
-                has("pointerType", x -> x.pointerType(), equalTo(LlvmCompilerClosures.CALLABLE_TYPES.closurePointer())),
+                has("pointerType", x -> x.pointerType(), equalTo(LlvmCodeGenClosures.CALLABLE_TYPES.closurePointer())),
                 has("pointer", x -> x.pointer(), isLlvmVariableLocal("closurePointer__0")),
                 has("indexes", x -> x.indexes(), isSequence(
                     isLlvmTypedOperand(LlvmTypes.INT_64, isLlvmOperandInt(0)),
@@ -100,23 +100,23 @@ public class LlvmCompilerCallTests {
             instanceOf(
                 LlvmLoad.class,
                 has("target", x -> x.target(), isLlvmVariableLocal("closureFunctionPointer__0")),
-                has("type", x -> x.type(), equalTo(LlvmCompilerClosures.CALLABLE_TYPES.closureFunctionPointer())),
+                has("type", x -> x.type(), equalTo(LlvmCodeGenClosures.CALLABLE_TYPES.closureFunctionPointer())),
                 has("pointer", x -> x.pointer(), isLlvmVariableLocal("closureFunctionPointerPointer__0"))
             ),
             instanceOf(
                 LlvmCall.class,
                 has("target", x -> x.target(), isOptionalOf(isLlvmVariableLocal("tmp__0"))),
-                has("returnType", x -> x.returnType(), equalTo(LlvmCompilerTypes.VALUE_TYPE)),
+                has("returnType", x -> x.returnType(), equalTo(LlvmCodeGenTypes.VALUE_TYPE)),
                 has("functionPointer", x -> x.functionPointer(), isLlvmVariableLocal("closureFunctionPointer__0")),
                 has("args", x -> x.args(), isSequence(
                     isLlvmTypedOperand(
-                        LlvmCompilerClosures.CALLABLE_TYPES.closurePointer(),
+                        LlvmCodeGenClosures.CALLABLE_TYPES.closurePointer(),
                         isLlvmVariableLocal("closurePointer__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"))
+                    isLlvmTypedOperand(LlvmCodeGenTypes.VALUE_TYPE, isLlvmVariableLocal("positional1")),
+                    isLlvmTypedOperand(LlvmCodeGenTypes.VALUE_TYPE, isLlvmVariableLocal("positional2")),
+                    isLlvmTypedOperand(LlvmCodeGenTypes.VALUE_TYPE, isLlvmVariableLocal("namedA")),
+                    isLlvmTypedOperand(LlvmCodeGenTypes.VALUE_TYPE, isLlvmVariableLocal("namedB"))
                 ))
             )
         ));
diff --git a/src/test/java/org/shedlang/compiler/backends/llvm/LlvmCompilerDefineFunctionTests.java b/src/test/java/org/shedlang/compiler/backends/llvm/LlvmCodeGenDefineFunctionTests.java
index c80787c0..f0e3cf23 100644
--- a/src/test/java/org/shedlang/compiler/backends/llvm/LlvmCompilerDefineFunctionTests.java
+++ b/src/test/java/org/shedlang/compiler/backends/llvm/LlvmCodeGenDefineFunctionTests.java
@@ -19,7 +19,7 @@ import static org.shedlang.compiler.util.Iterables.forEachInterspersed;
 import static org.zwobble.precisely.AssertThat.assertThat;
 import static org.zwobble.precisely.Matchers.*;
 
-public class LlvmCompilerDefineFunctionTests {
+public class LlvmCodeGenDefineFunctionTests {
     @Test
     public void canDefineMinimalFunction() throws IOException {
         var instruction = new DefineFunctionInstruction(
@@ -33,9 +33,9 @@ public class LlvmCompilerDefineFunctionTests {
             ),
             Sources.NULL
         );
-        var context = LlvmCompilerContext.EMPTY;
+        var context = LlvmCodeGenContext.EMPTY;
 
-        var result = LlvmCompiler.compileInstruction(instruction, context);
+        var result = LlvmCodeGen.generateInstruction(instruction, context);
 
         var topLevelEntities = new StringBuilder();
         forEachInterspersed(
@@ -82,11 +82,11 @@ public class LlvmCompilerDefineFunctionTests {
             ),
             Sources.NULL
         );
-        var context = LlvmCompilerContext.EMPTY
+        var context = LlvmCodeGenContext.EMPTY
             .addLocal("a", LlvmIr.operandInt(1))
             .addLocal("b", LlvmIr.operandInt(2));
 
-        var result = LlvmCompiler.compileInstruction(instruction, context);
+        var result = LlvmCodeGen.generateInstruction(instruction, context);
 
         var topLevelEntities = new StringBuilder();
         forEachInterspersed(
diff --git a/src/test/java/org/shedlang/compiler/backends/llvm/LlvmCompilerDiscardTests.java b/src/test/java/org/shedlang/compiler/backends/llvm/LlvmCodeGenDiscardTests.java
index c263caa1..799442eb 100644
--- a/src/test/java/org/shedlang/compiler/backends/llvm/LlvmCompilerDiscardTests.java
+++ b/src/test/java/org/shedlang/compiler/backends/llvm/LlvmCodeGenDiscardTests.java
@@ -8,15 +8,15 @@ import static org.shedlang.compiler.backends.llvm.ir.ast.LlvmIrMatchers.isLlvmOp
 import static org.zwobble.precisely.AssertThat.assertThat;
 import static org.zwobble.precisely.Matchers.isSequence;
 
-public class LlvmCompilerDiscardTests {
+public class LlvmCodeGenDiscardTests {
     @Test
     public void discardRemovesTopElementFromStack() {
         var instruction = Instructions.discard();
-        var context = LlvmCompilerContext.EMPTY
+        var context = LlvmCodeGenContext.EMPTY
             .push(LlvmIr.operandInt(1))
             .push(LlvmIr.operandInt(2));
 
-        var result = LlvmCompiler.compileInstruction(instruction, context);
+        var result = LlvmCodeGen.generateInstruction(instruction, context);
 
         assertThat(result.instructions(), isSequence());
         assertThat(result.stack(), isSequence(isLlvmOperandInt(1)));
diff --git a/src/test/java/org/shedlang/compiler/backends/llvm/LlvmCompilerLocalLoadTests.java b/src/test/java/org/shedlang/compiler/backends/llvm/LlvmCodeGenLocalLoadTests.java
index 74f5114f..487e184e 100644
--- a/src/test/java/org/shedlang/compiler/backends/llvm/LlvmCompilerLocalLoadTests.java
+++ b/src/test/java/org/shedlang/compiler/backends/llvm/LlvmCodeGenLocalLoadTests.java
@@ -12,14 +12,14 @@ import static org.shedlang.compiler.backends.llvm.ir.ast.LlvmIrMatchers.isLlvmOp
 import static org.zwobble.precisely.AssertThat.assertThat;
 import static org.zwobble.precisely.Matchers.*;
 
-public class LlvmCompilerLocalLoadTests {
+public class LlvmCodeGenLocalLoadTests {
     @Test
     public void localLoadPushsOperandFromLocalsToStack() {
         var instruction = Instructions.localLoad("x");
-        var context = LlvmCompilerContext.EMPTY
+        var context = LlvmCodeGenContext.EMPTY
             .addLocal("x", LlvmIr.operandInt(42));
 
-        var result = LlvmCompiler.compileInstruction(instruction, context);
+        var result = LlvmCodeGen.generateInstruction(instruction, context);
 
         assertThat(result.instructions(), isSequence());
         assertThat(result.stack(), isSequence(isLlvmOperandInt(42)));
diff --git a/src/test/java/org/shedlang/compiler/backends/llvm/LlvmCompilerLocalStoreTests.java b/src/test/java/org/shedlang/compiler/backends/llvm/LlvmCodeGenLocalStoreTests.java
index 2f20ec85..1461db1b 100644
--- a/src/test/java/org/shedlang/compiler/backends/llvm/LlvmCompilerLocalStoreTests.java
+++ b/src/test/java/org/shedlang/compiler/backends/llvm/LlvmCodeGenLocalStoreTests.java
@@ -12,15 +12,15 @@ import static org.shedlang.compiler.backends.llvm.ir.ast.LlvmIrMatchers.isLlvmOp
 import static org.zwobble.precisely.AssertThat.assertThat;
 import static org.zwobble.precisely.Matchers.*;
 
-public class LlvmCompilerLocalStoreTests {
+public class LlvmCodeGenLocalStoreTests {
     @Test
     public void localStorePopsFromStackAndUpdatesLocals() {
         var instruction = Instructions.localStore("x");
-        var context = LlvmCompilerContext.EMPTY
+        var context = LlvmCodeGenContext.EMPTY
             .push(LlvmIr.operandInt(0))
             .push(LlvmIr.operandInt(1));
 
-        var result = LlvmCompiler.compileInstruction(instruction, context);
+        var result = LlvmCodeGen.generateInstruction(instruction, context);
 
         assertThat(result.instructions(), isSequence());
         assertThat(result.stack(), isSequence(isLlvmOperandInt(0)));
diff --git a/src/test/java/org/shedlang/compiler/backends/llvm/LlvmCompilerNamespaceFieldStoreTests.java b/src/test/java/org/shedlang/compiler/backends/llvm/LlvmCodeGenNamespaceFieldStoreTests.java
index 96118890..191361e7 100644
--- a/src/test/java/org/shedlang/compiler/backends/llvm/LlvmCompilerNamespaceFieldStoreTests.java
+++ b/src/test/java/org/shedlang/compiler/backends/llvm/LlvmCodeGenNamespaceFieldStoreTests.java
@@ -18,7 +18,7 @@ import static org.shedlang.compiler.backends.llvm.ir.ast.LlvmIrMatchers.*;
 import static org.zwobble.precisely.AssertThat.assertThat;
 import static org.zwobble.precisely.Matchers.*;
 
-public class LlvmCompilerNamespaceFieldStoreTests {
+public class LlvmCodeGenNamespaceFieldStoreTests {
     @Test
     public void namespaceFieldStorePopsFromStackAndUpdatesFieldOnNamespace() {
         var namespaceName = new NamespaceName(List.of("Example", "Project"));
@@ -30,11 +30,11 @@ public class LlvmCompilerNamespaceFieldStoreTests {
                 Map.entry("z", Types.INT)
             ))
             .toTypeInfo();
-        var context = LlvmCompilerContext.fromTypeInfo(typeInfo)
+        var context = LlvmCodeGenContext.fromTypeInfo(typeInfo)
             .push(LlvmIr.operandInt(0))
             .push(LlvmIr.operandInt(1));
 
-        var result = LlvmCompiler.compileInstruction(instruction, context);
+        var result = LlvmCodeGen.generateInstruction(instruction, context);
 
         assertThat(result.instructions(), isSequence(
             instanceOf(
diff --git a/src/test/java/org/shedlang/compiler/backends/llvm/LlvmCompilerPushBoolTests.java b/src/test/java/org/shedlang/compiler/backends/llvm/LlvmCodeGenPushBoolTests.java
index b677704a..cf6bb76a 100644
--- a/src/test/java/org/shedlang/compiler/backends/llvm/LlvmCompilerPushBoolTests.java
+++ b/src/test/java/org/shedlang/compiler/backends/llvm/LlvmCodeGenPushBoolTests.java
@@ -7,13 +7,13 @@ import static org.shedlang.compiler.backends.llvm.ir.ast.LlvmIrMatchers.isLlvmOp
 import static org.zwobble.precisely.AssertThat.assertThat;
 import static org.zwobble.precisely.Matchers.isSequence;
 
-public class LlvmCompilerPushBoolTests {
+public class LlvmCodeGenPushBoolTests {
     @Test
     public void pushFalseIsCompiledToOperandInStack() {
         var instruction = Instructions.pushBool(false);
-        var context = LlvmCompilerContext.EMPTY;
+        var context = LlvmCodeGenContext.EMPTY;
 
-        var result = LlvmCompiler.compileInstruction(instruction, context);
+        var result = LlvmCodeGen.generateInstruction(instruction, context);
 
         assertThat(result.instructions(), isSequence());
         assertThat(result.stack(), isSequence(isLlvmOperandInt(0)));
@@ -22,9 +22,9 @@ public class LlvmCompilerPushBoolTests {
     @Test
     public void pushTrueIsCompiledToOperandInStack() {
         var instruction = Instructions.pushBool(true);
-        var context = LlvmCompilerContext.EMPTY;
+        var context = LlvmCodeGenContext.EMPTY;
 
-        var result = LlvmCompiler.compileInstruction(instruction, context);
+        var result = LlvmCodeGen.generateInstruction(instruction, context);
 
         assertThat(result.instructions(), isSequence());
         assertThat(result.stack(), isSequence(isLlvmOperandInt(1)));
diff --git a/src/test/java/org/shedlang/compiler/backends/llvm/LlvmCompilerPushIntTests.java b/src/test/java/org/shedlang/compiler/backends/llvm/LlvmCodeGenPushIntTests.java
index 983a1661..cb4711d9 100644
--- a/src/test/java/org/shedlang/compiler/backends/llvm/LlvmCompilerPushIntTests.java
+++ b/src/test/java/org/shedlang/compiler/backends/llvm/LlvmCodeGenPushIntTests.java
@@ -7,15 +7,15 @@ import static org.shedlang.compiler.backends.llvm.ir.ast.LlvmIrMatchers.isLlvmOp
 import static org.zwobble.precisely.AssertThat.assertThat;
 import static org.zwobble.precisely.Matchers.isSequence;
 
-public class LlvmCompilerPushIntTests {
+public class LlvmCodeGenPushIntTests {
     // TODO: handle larger ints
 
     @Test
     public void pushIntIsCompiledToOperandInStack() {
         var instruction = Instructions.pushInt(42);
-        var context = LlvmCompilerContext.EMPTY;
+        var context = LlvmCodeGenContext.EMPTY;
 
-        var result = LlvmCompiler.compileInstruction(instruction, context);
+        var result = LlvmCodeGen.generateInstruction(instruction, context);
 
         assertThat(result.instructions(), isSequence());
         assertThat(result.stack(), isSequence(isLlvmOperandInt(42)));
diff --git a/src/test/java/org/shedlang/compiler/backends/llvm/LlvmCompilerPushStringTests.java b/src/test/java/org/shedlang/compiler/backends/llvm/LlvmCodeGenPushStringTests.java
index 761fbd18..0504084e 100644
--- a/src/test/java/org/shedlang/compiler/backends/llvm/LlvmCompilerPushStringTests.java
+++ b/src/test/java/org/shedlang/compiler/backends/llvm/LlvmCodeGenPushStringTests.java
@@ -12,13 +12,13 @@ import static org.shedlang.compiler.backends.llvm.ir.ast.LlvmIrMatchers.*;
 import static org.zwobble.precisely.AssertThat.assertThat;
 import static org.zwobble.precisely.Matchers.*;
 
-public class LlvmCompilerPushStringTests {
+public class LlvmCodeGenPushStringTests {
     @Test
     public void pushStringIsCompiledToTopLevelEntityAndReferenceToTopLevelEntity() {
         var instruction = Instructions.pushString("hello");
-        var context = LlvmCompilerContext.EMPTY;
+        var context = LlvmCodeGenContext.EMPTY;
 
-        var result = LlvmCompiler.compileInstruction(instruction, context);
+        var result = LlvmCodeGen.generateInstruction(instruction, context);
 
         assertThat(result.instructions(), isSequence());
         assertThat(result.stack(), isSequence(
diff --git a/src/test/java/org/shedlang/compiler/backends/llvm/LlvmCompilerPushUnitTests.java b/src/test/java/org/shedlang/compiler/backends/llvm/LlvmCodeGenPushUnitTests.java
index 7a3da398..2da03372 100644
--- a/src/test/java/org/shedlang/compiler/backends/llvm/LlvmCompilerPushUnitTests.java
+++ b/src/test/java/org/shedlang/compiler/backends/llvm/LlvmCodeGenPushUnitTests.java
@@ -7,13 +7,13 @@ import static org.shedlang.compiler.backends.llvm.ir.ast.LlvmIrMatchers.isLlvmOp
 import static org.zwobble.precisely.AssertThat.assertThat;
 import static org.zwobble.precisely.Matchers.isSequence;
 
-public class LlvmCompilerPushUnitTests {
+public class LlvmCodeGenPushUnitTests {
     @Test
     public void pushUnitIsCompiledToOperandInStack() {
         var instruction = Instructions.pushUnit();
-        var context = LlvmCompilerContext.EMPTY;
+        var context = LlvmCodeGenContext.EMPTY;
 
-        var result = LlvmCompiler.compileInstruction(instruction, context);
+        var result = LlvmCodeGen.generateInstruction(instruction, context);
 
         assertThat(result.instructions(), isSequence());
         assertThat(result.stack(), isSequence(isLlvmOperandInt(0)));
diff --git a/src/test/java/org/shedlang/compiler/backends/llvm/LlvmCompilerReturnTests.java b/src/test/java/org/shedlang/compiler/backends/llvm/LlvmCodeGenReturnTests.java
index f76383af..66afa268 100644
--- a/src/test/java/org/shedlang/compiler/backends/llvm/LlvmCompilerReturnTests.java
+++ b/src/test/java/org/shedlang/compiler/backends/llvm/LlvmCodeGenReturnTests.java
@@ -10,7 +10,7 @@ import static org.zwobble.precisely.AssertThat.assertThat;
 import static org.zwobble.precisely.Matchers.equalTo;
 import static org.zwobble.precisely.Matchers.isSequence;
 
-public class LlvmCompilerReturnTests {
+public class LlvmCodeGenReturnTests {
     @Test
     public void returnCompilesToReturnInstruction() {
         var instruction = Instructions.return_();
@@ -20,19 +20,19 @@ public class LlvmCompilerReturnTests {
             LlvmIr.variableLocal("left"),
             LlvmIr.variableLocal("right")
         );
-        var context = LlvmCompilerContext.EMPTY
+        var context = LlvmCodeGenContext.EMPTY
             .addInstruction(add)
             .push(LlvmIr.variableLocal("a"))
             .push(LlvmIr.variableLocal("b"));
 
-        var result = LlvmCompiler.compileInstruction(instruction, context);
+        var result = LlvmCodeGen.generateInstruction(instruction, context);
 
         assertThat(result.basicBlocks(), isSequence(
             isLlvmBasicBlock(
                 isSequence(
                     equalTo(add)
                 ),
-                isLlvmReturn(LlvmCompilerTypes.VALUE_TYPE, isLlvmVariableLocal("b"))
+                isLlvmReturn(LlvmCodeGenTypes.VALUE_TYPE, isLlvmVariableLocal("b"))
             )
         ));
         assertThat(result.instructions(), isSequence());