Rename LlvmCompiler to LlvmCodeGen

14 files changed, 157 insertions, 157 deletions

diff --git a/src/main/java/org/shedlang/compiler/backends/llvm/LlvmBackend.java b/src/main/java/org/shedlang/compiler/backends/llvm/LlvmBackend.java
index 49b55160..2684f18a 100644
--- a/src/main/java/org/shedlang/compiler/backends/llvm/LlvmBackend.java
+++ b/src/main/java/org/shedlang/compiler/backends/llvm/LlvmBackend.java
@@ -30,7 +30,7 @@ public class LlvmBackend implements Backend {
         var objectFilePaths = new ArrayList<Path>();
         for (var namespace : namespaces.entrySet()) {
             var namespaceName = namespace.getKey();
-            var llvmModule = LlvmCompiler.compileNamespace(
+            var llvmModule = LlvmCodeGen.generateNamespace(
                 namespaceName,
                 namespace.getValue(),
                 typeInfo
@@ -41,7 +41,7 @@ public class LlvmBackend implements Backend {
         }
 
         for (var bin : config.bins()) {
-            var mainModule = LlvmCompiler.compileMain(config.main(), typeInfo);
+            var mainModule = LlvmCodeGen.generateMain(config.main(), typeInfo);
             var objectPath = compileLlvmModule(mainModule, targetDir.resolve("bins"), bin.name());
             objectFilePaths.add(objectPath);
 
diff --git a/src/main/java/org/shedlang/compiler/backends/llvm/LlvmCompiler.java b/src/main/java/org/shedlang/compiler/backends/llvm/LlvmCodeGen.java
index c9d8c8ee..e0060e9d 100644
--- a/src/main/java/org/shedlang/compiler/backends/llvm/LlvmCompiler.java
+++ b/src/main/java/org/shedlang/compiler/backends/llvm/LlvmCodeGen.java
@@ -16,17 +16,17 @@ import java.util.*;
 
 import static org.shedlang.compiler.util.Lists.reversed;
 
-public class LlvmCompiler {
-    public static LlvmModule compileMain(NamespaceName main, TypeInfo typeInfo) {
-        var context = LlvmCompilerContext.fromTypeInfo(typeInfo);
+public class LlvmCodeGen {
+    public static LlvmModule generateMain(NamespaceName main, TypeInfo typeInfo) {
+        var context = LlvmCodeGenContext.fromTypeInfo(typeInfo);
 
         var mainContext = context.enterFunction();
 
-        var namespaceResult = LlvmCompilerNamespaces.importValue(main, mainContext);
+        var namespaceResult = LlvmCodeGenNamespaces.importValue(main, mainContext);
         var namespace = namespaceResult.value();
         mainContext = namespaceResult.context();
 
-        var fieldResult = LlvmCompilerNamespaces.fieldLoad(
+        var fieldResult = LlvmCodeGenNamespaces.fieldLoad(
             main,
             namespace,
             // TODO: check there is a main function
@@ -36,7 +36,7 @@ public class LlvmCompiler {
         var field = fieldResult.value();
         mainContext = fieldResult.context();
 
-        mainContext = LlvmCompilerClosures.call(field, mainContext, List.of());
+        mainContext = LlvmCodeGenClosures.call(field, mainContext, List.of());
 
         mainContext = mainContext.addTerminatorInstruction(
             new LlvmReturn(LlvmTypes.INT_32, new LlvmOperandInt(0))
@@ -56,25 +56,25 @@ public class LlvmCompiler {
         return new LlvmModule(context.topLevelEntities());
     }
 
-    public static LlvmModule compileNamespace(
+    public static LlvmModule generateNamespace(
         NamespaceName namespaceName,
         List<Instruction> instructions,
         TypeInfo typeInfo
     ) {
         var context = defaultContext(typeInfo);
         for (var instruction : instructions) {
-            context = compileInstruction(instruction, context);
+            context = generateInstruction(instruction, context);
         }
 
-        context = LlvmCompilerNamespaces.define(namespaceName, context);
+        context = LlvmCodeGenNamespaces.define(namespaceName, context);
 
         var topLevelEntities = context.topLevelEntities();
 
         return new LlvmModule(topLevelEntities);
     }
 
-    private static LlvmCompilerContext defaultContext(TypeInfo typeInfo) {
-        return LlvmCompilerContext.fromTypeInfo(typeInfo)
+    private static LlvmCodeGenContext defaultContext(TypeInfo typeInfo) {
+        return LlvmCodeGenContext.fromTypeInfo(typeInfo)
             .addTopLevelEntity(new LlvmFunctionDeclaration(
                 "shed__runtime__alloc",
                 LlvmTypes.pointer(LlvmTypes.INT_8),
@@ -82,7 +82,7 @@ public class LlvmCompiler {
             ))
             .addTopLevelEntity(new LlvmGlobalDefinition(
                 "shed__runtime__print_closure",
-                new LlvmCompilerClosures.Types(Optional.of(FreeVariables.empty())).closureStruct(),
+                new LlvmCodeGenClosures.Types(Optional.of(FreeVariables.empty())).closureStruct(),
                 Optional.empty(),
                 false,
                 false,
@@ -90,11 +90,11 @@ public class LlvmCompiler {
             ))
             .addLocal("print", new LlvmOperandPtrToInt(
                 new LlvmVariableGlobal("shed__runtime__print_closure"),
-                LlvmCompilerTypes.VALUE_TYPE
+                LlvmCodeGenTypes.VALUE_TYPE
             ));
     }
 
-    public static LlvmCompilerContext compileInstruction(Instruction instruction, LlvmCompilerContext context) {
+    public static LlvmCodeGenContext generateInstruction(Instruction instruction, LlvmCodeGenContext context) {
         return switch (instruction) {
             case CallInstruction call -> {
                 var namedArgsByName = new HashMap<String, LlvmOperand>();
@@ -123,19 +123,19 @@ public class LlvmCompiler {
                 var receiver = receiverResult.value();
                 context = receiverResult.context();
 
-                yield LlvmCompilerClosures.call(
+                yield LlvmCodeGenClosures.call(
                     receiver,
                     context,
                     args
                 );
             }
             case DefineFunctionInstruction defineFunction -> {
-                yield LlvmCompilerClosures.create(
+                yield LlvmCodeGenClosures.create(
                     defineFunction.name(),
                     defineFunction.freeVariables(),
                     functionContext -> {
                         for (var bodyInstruction : defineFunction.body()) {
-                            functionContext = compileInstruction(bodyInstruction, functionContext);
+                            functionContext = generateInstruction(bodyInstruction, functionContext);
                         }
                         return functionContext;
                     },
@@ -161,7 +161,7 @@ public class LlvmCompiler {
                 var fieldValue = popResult.value();
                 context = popResult.context();
 
-                yield LlvmCompilerNamespaces.fieldStore(
+                yield LlvmCodeGenNamespaces.fieldStore(
                     namespaceFieldStore.namespaceName(),
                     namespaceFieldStore.fieldName(),
                     fieldValue,
@@ -176,11 +176,11 @@ public class LlvmCompiler {
                 context.push(new LlvmOperandInt(pushInt.value().longValueExact()));
 
             case PushStringInstruction pushString -> {
-                var result = LlvmCompilerStrings.defineString(pushString.value(), context);
+                var result = LlvmCodeGenStrings.defineString(pushString.value(), context);
                 var globalDefinition = result.value();
                 context = result.context();
 
-                yield context.push(LlvmCompilerStrings.operandAsShedObject(globalDefinition));
+                yield context.push(LlvmCodeGenStrings.operandAsShedObject(globalDefinition));
             }
 
             case PushUnitInstruction pushUnit ->
@@ -192,7 +192,7 @@ public class LlvmCompiler {
                 context = result.context();
 
                 yield context.addTerminatorInstruction(
-                    new LlvmReturn(LlvmCompilerTypes.VALUE_TYPE, value)
+                    new LlvmReturn(LlvmCodeGenTypes.VALUE_TYPE, value)
                 );
             }
         };
diff --git a/src/main/java/org/shedlang/compiler/backends/llvm/LlvmCompilerClosures.java b/src/main/java/org/shedlang/compiler/backends/llvm/LlvmCodeGenClosures.java
index 1f977db2..88849d2a 100644
--- a/src/main/java/org/shedlang/compiler/backends/llvm/LlvmCompilerClosures.java
+++ b/src/main/java/org/shedlang/compiler/backends/llvm/LlvmCodeGenClosures.java
@@ -16,8 +16,8 @@ import java.util.List;
 import java.util.Optional;
 import java.util.function.Function;
 
-public class LlvmCompilerClosures {
-    private LlvmCompilerClosures() {
+public class LlvmCodeGenClosures {
+    private LlvmCodeGenClosures() {
     }
 
     public record Types(Optional<FreeVariables> freeVariables) {
@@ -38,7 +38,7 @@ public class LlvmCompilerClosures {
 
         public LlvmTypeFunction closureFunction() {
             return LlvmTypes.function(
-                LlvmCompilerTypes.VALUE_TYPE,
+                LlvmCodeGenTypes.VALUE_TYPE,
                 List.of(closureEnvironmentPointer())
             );
         }
@@ -48,7 +48,7 @@ public class LlvmCompilerClosures {
         }
 
         public LlvmTypeArray closureEnvironment() {
-            return LlvmTypes.array(freeVariables.map(x -> x.size()).orElse(0), LlvmCompilerTypes.VALUE_TYPE);
+            return LlvmTypes.array(freeVariables.map(x -> x.size()).orElse(0), LlvmCodeGenTypes.VALUE_TYPE);
         }
     }
 
@@ -62,22 +62,22 @@ public class LlvmCompilerClosures {
         return new Types(freeVariables);
     }
 
-    public static LlvmCompilerContext create(
+    public static LlvmCodeGenContext create(
         String name,
         FreeVariables freeVariables,
-        Function<LlvmCompilerContext, LlvmCompilerContext> compileBody,
-        LlvmCompilerContext context
+        Function<LlvmCodeGenContext, LlvmCodeGenContext> compileBody,
+        LlvmCodeGenContext context
     ) {
-        var closureTypes = LlvmCompilerClosures.types(freeVariables);
+        var closureTypes = LlvmCodeGenClosures.types(freeVariables);
 
         var topLevelEntityName = context.generateTopLevelEntityName(
-            LlvmCompilerTopLevelEntitySpace.FUNCTION,
+            LlvmCodeGenTopLevelEntitySpace.FUNCTION,
             name
         );
 
         var functionContext = context.enterFunction();
         var functionClosurePointerResult = functionContext.generateVariableLocal(
-            LlvmCompilerLocalVariableSpace.CLOSURE_POINTER
+            LlvmCodeGenLocalVariableSpace.CLOSURE_POINTER
         );
         var functionClosurePointer = functionClosurePointerResult.value();
         functionContext = functionClosurePointerResult.context();
@@ -98,7 +98,7 @@ public class LlvmCompilerClosures {
 
         context = context.addTopLevelEntity(new LlvmFunctionDefinition(
             topLevelEntityName,
-            LlvmCompilerTypes.VALUE_TYPE,
+            LlvmCodeGenTypes.VALUE_TYPE,
             List.of(
                 new LlvmParam(
                     closureTypes.closurePointer(),
@@ -109,7 +109,7 @@ public class LlvmCompilerClosures {
         ));
 
         var closurePointerResult = context.generateVariableLocal(
-            LlvmCompilerLocalVariableSpace.CLOSURE_POINTER
+            LlvmCodeGenLocalVariableSpace.CLOSURE_POINTER
         );
         var closurePointer = closurePointerResult.value();
         context = closurePointerResult.context();
@@ -121,7 +121,7 @@ public class LlvmCompilerClosures {
         var closureSize = closureSizeResult.value();
         context = closureSizeResult.context();
 
-        context = LlvmCompilerRuntime.callAlloc(
+        context = LlvmCodeGenRuntime.callAlloc(
             closurePointer,
             closureTypes.closurePointer(),
             closureSize,
@@ -153,9 +153,9 @@ public class LlvmCompilerClosures {
         return context;
     }
 
-    public static LlvmCompilerContext call(
+    public static LlvmCodeGenContext call(
         LlvmOperand closure,
-        LlvmCompilerContext context,
+        LlvmCodeGenContext context,
         List<LlvmOperand> args
     ) {
         var closurePointerResult = castValueToClosurePointer(closure, context);
@@ -167,7 +167,7 @@ public class LlvmCompilerClosures {
         context = functionPointerResult.context();
 
         var callTargetResult = context.generateVariableLocal(
-            LlvmCompilerLocalVariableSpace.TEMPORARY
+            LlvmCodeGenLocalVariableSpace.TEMPORARY
         );
         var callTarget = callTargetResult.value();
         context = callTargetResult.context();
@@ -175,23 +175,23 @@ public class LlvmCompilerClosures {
         var fullArgs = new ArrayList<LlvmTypedOperand>();
         fullArgs.add(new LlvmTypedOperand(CALLABLE_TYPES.closurePointer(), closurePointer));
         for (var arg : args) {
-            fullArgs.add(new LlvmTypedOperand(LlvmCompilerTypes.VALUE_TYPE, arg));
+            fullArgs.add(new LlvmTypedOperand(LlvmCodeGenTypes.VALUE_TYPE, arg));
         }
 
         return context.addInstruction(new LlvmCall(
             callTarget,
-            LlvmCompilerTypes.VALUE_TYPE,
+            LlvmCodeGenTypes.VALUE_TYPE,
             functionPointer,
             fullArgs
         )).push(callTarget);
     }
 
-    private static LlvmCompilerResult<LlvmVariableLocal> castClosurePointerToValue(
+    private static LlvmCodeGenResult<LlvmVariableLocal> castClosurePointerToValue(
         LlvmOperand closurePointer,
-        LlvmCompilerContext context
+        LlvmCodeGenContext context
     ) {
         var closureValueResult = context.generateVariableLocal(
-            LlvmCompilerLocalVariableSpace.CLOSURE_VALUE
+            LlvmCodeGenLocalVariableSpace.CLOSURE_VALUE
         );
         var closureValue = closureValueResult.value();
         context = closureValueResult.context();
@@ -199,36 +199,36 @@ public class LlvmCompilerClosures {
         context = context.addInstruction(new LlvmPtrToInt(
             closureValue,
             closurePointer,
-            LlvmCompilerTypes.VALUE_TYPE
+            LlvmCodeGenTypes.VALUE_TYPE
         ));
 
         return context.toResult(closureValue);
     }
 
-    private static LlvmCompilerResult<LlvmVariableLocal> castValueToClosurePointer(
+    private static LlvmCodeGenResult<LlvmVariableLocal> castValueToClosurePointer(
         LlvmOperand value,
-        LlvmCompilerContext context
+        LlvmCodeGenContext context
     ) {
         var closurePointerResult = context.generateVariableLocal(
-            LlvmCompilerLocalVariableSpace.CLOSURE_POINTER
+            LlvmCodeGenLocalVariableSpace.CLOSURE_POINTER
         );
         var closurePointer = closurePointerResult.value();
         context = closurePointerResult.context();
 
         context = context.addInstruction(new LlvmIntToPtr(
             closurePointer,
-            LlvmCompilerTypes.VALUE_TYPE,
+            LlvmCodeGenTypes.VALUE_TYPE,
             value
         ));
 
         return context.toResult(closurePointer);
     }
 
-    private static LlvmCompilerContext storeClosureFunctionPointer(
+    private static LlvmCodeGenContext storeClosureFunctionPointer(
         LlvmOperand closurePointer,
         Types closureTypes,
         LlvmOperand function,
-        LlvmCompilerContext context
+        LlvmCodeGenContext context
     ) {
         var closureFunctionPointerPointerResult = getClosureFunctionPointerPointer(
             closurePointer,
@@ -245,9 +245,9 @@ public class LlvmCompilerClosures {
         ));
     }
 
-    private static LlvmCompilerResult<LlvmVariableLocal> loadClosureFunctionPointer(
+    private static LlvmCodeGenResult<LlvmVariableLocal> loadClosureFunctionPointer(
         LlvmOperand closurePointer,
-        LlvmCompilerContext context
+        LlvmCodeGenContext context
     ) {
         var functionPointerPointerResult = getClosureFunctionPointerPointer(
             closurePointer,
@@ -258,7 +258,7 @@ public class LlvmCompilerClosures {
         context = functionPointerPointerResult.context();
 
         var functionPointerResult = context.generateVariableLocal(
-            LlvmCompilerLocalVariableSpace.CLOSURE_FUNCTION_POINTER
+            LlvmCodeGenLocalVariableSpace.CLOSURE_FUNCTION_POINTER
         );
         var functionPointer = functionPointerResult.value();
         context = functionPointerResult.context();
@@ -270,13 +270,13 @@ public class LlvmCompilerClosures {
         )).toResult(functionPointer);
     }
 
-    private static LlvmCompilerResult<LlvmVariableLocal> getClosureFunctionPointerPointer(
+    private static LlvmCodeGenResult<LlvmVariableLocal> getClosureFunctionPointerPointer(
         LlvmOperand closurePointer,
         Types closureTypes,
-        LlvmCompilerContext context
+        LlvmCodeGenContext context
     ) {
         var functionPointerPointerResult = context.generateVariableLocal(
-            LlvmCompilerLocalVariableSpace.CLOSURE_FUNCTION_POINTER_POINTER
+            LlvmCodeGenLocalVariableSpace.CLOSURE_FUNCTION_POINTER_POINTER
         );
         var functionPointerPointer = functionPointerPointerResult.value();
         context = functionPointerPointerResult.context();
@@ -291,12 +291,12 @@ public class LlvmCompilerClosures {
         return context.toResult(functionPointerPointer);
     }
 
-    private static LlvmCompilerResult<LlvmVariableLocal> getClosureEnvironmentPointer(
+    private static LlvmCodeGenResult<LlvmVariableLocal> getClosureEnvironmentPointer(
         LlvmOperand closurePointer,
-        LlvmCompilerContext context
+        LlvmCodeGenContext context
     ) {
         var environmentPointerResult = context.generateVariableLocal(
-            LlvmCompilerLocalVariableSpace.CLOSURE_ENVIRONMENT_POINTER
+            LlvmCodeGenLocalVariableSpace.CLOSURE_ENVIRONMENT_POINTER
         );
         var environmentPointer = environmentPointerResult.value();
         context = environmentPointerResult.context();
@@ -311,11 +311,11 @@ public class LlvmCompilerClosures {
         return context.toResult(environmentPointer);
     }
 
-    private static LlvmCompilerContext storeClosureFreeVariable(
+    private static LlvmCodeGenContext storeClosureFreeVariable(
         LlvmOperand closurePointer,
         FreeVariable freeVariable,
         Types closureTypes,
-        LlvmCompilerContext context
+        LlvmCodeGenContext context
     ) {
         var closureEnvironmentPointerResult = getClosureFreeVariablePointer(
             closurePointer,
@@ -327,17 +327,17 @@ public class LlvmCompilerClosures {
         context = closureEnvironmentPointerResult.context();
 
         return context.addInstruction(new LlvmStore(
-            LlvmCompilerTypes.VALUE_TYPE,
+            LlvmCodeGenTypes.VALUE_TYPE,
             context.local(freeVariable.name()),
             closureEnvironmentPointer
         ));
     }
 
-    private static LlvmCompilerContext loadClosureFreeVariable(
+    private static LlvmCodeGenContext loadClosureFreeVariable(
         LlvmOperand closurePointer,
         FreeVariable freeVariable,
         Types closureTypes,
-        LlvmCompilerContext context
+        LlvmCodeGenContext context
     ) {
         var closureFreeVariablePointerResult = getClosureFreeVariablePointer(
             closurePointer,
@@ -349,7 +349,7 @@ public class LlvmCompilerClosures {
         context = closureFreeVariablePointerResult.context();
 
         var closureFreeVariableResult = context.generateVariableLocal(
-            LlvmCompilerLocalVariableSpace.CLOSURE_FREE_VARIABLE,
+            LlvmCodeGenLocalVariableSpace.CLOSURE_FREE_VARIABLE,
             freeVariable.name()
         );
         var closureFreeVariable = closureFreeVariableResult.value();
@@ -357,21 +357,21 @@ public class LlvmCompilerClosures {
 
         context = context.addInstruction(new LlvmLoad(
             closureFreeVariable,
-            LlvmCompilerTypes.VALUE_TYPE,
+            LlvmCodeGenTypes.VALUE_TYPE,
             closureFreeVariablePointer
         ));
 
         return context.addLocal(freeVariable.name(), closureFreeVariable);
     }
 
-    private static LlvmCompilerResult<LlvmVariableLocal> getClosureFreeVariablePointer(
+    private static LlvmCodeGenResult<LlvmVariableLocal> getClosureFreeVariablePointer(
         LlvmOperand closurePointer,
         FreeVariable freeVariable,
         Types closureTypes,
-        LlvmCompilerContext context
+        LlvmCodeGenContext context
     ) {
         var freeVariablePointerResult = context.generateVariableLocal(
-            LlvmCompilerLocalVariableSpace.CLOSURE_FREE_VARIABLE_POINTER,
+            LlvmCodeGenLocalVariableSpace.CLOSURE_FREE_VARIABLE_POINTER,
             freeVariable.name()
         );
         var freeVariablePointer = freeVariablePointerResult.value();
diff --git a/src/main/java/org/shedlang/compiler/backends/llvm/LlvmCompilerContext.java b/src/main/java/org/shedlang/compiler/backends/llvm/LlvmCodeGenContext.java
index e884d9e8..60137e9d 100644
--- a/src/main/java/org/shedlang/compiler/backends/llvm/LlvmCompilerContext.java
+++ b/src/main/java/org/shedlang/compiler/backends/llvm/LlvmCodeGenContext.java
@@ -17,19 +17,19 @@ import org.shedlang.compiler.util.POrderedMap;
 import java.util.List;
 import java.util.Optional;
 
-public record LlvmCompilerContext(
+public record LlvmCodeGenContext(
     TypeInfo typeInfo,
     PStack<LlvmOperand> stack,
     PMap<String, LlvmOperand> locals,
     PVector<LlvmBasicBlock> basicBlocks,
     PVector<LlvmInstruction> instructions,
     POrderedMap<String, LlvmTopLevelEntity> topLevelEntitiesByName,
-    NameAllocator<LlvmCompilerLocalVariableSpace> localVariableNames
+    NameAllocator<LlvmCodeGenLocalVariableSpace> localVariableNames
 ) {
-    public static LlvmCompilerContext EMPTY = fromTypeInfo(TypeInfo.EMPTY);
+    public static LlvmCodeGenContext EMPTY = fromTypeInfo(TypeInfo.EMPTY);
 
-    public static LlvmCompilerContext fromTypeInfo(TypeInfo typeInfo) {
-        return new LlvmCompilerContext(
+    public static LlvmCodeGenContext fromTypeInfo(TypeInfo typeInfo) {
+        return new LlvmCodeGenContext(
             typeInfo,
             Empty.stack(),
             Empty.map(),
@@ -40,8 +40,8 @@ public record LlvmCompilerContext(
         );
     }
 
-    public LlvmCompilerContext push(LlvmOperand operand) {
-        return new LlvmCompilerContext(
+    public LlvmCodeGenContext push(LlvmOperand operand) {
+        return new LlvmCodeGenContext(
             typeInfo,
             stack.plus(operand),
             locals,
@@ -52,8 +52,8 @@ public record LlvmCompilerContext(
         );
     }
 
-    public LlvmCompilerResult<LlvmOperand> pop() {
-        return new LlvmCompilerContext(
+    public LlvmCodeGenResult<LlvmOperand> pop() {
+        return new LlvmCodeGenContext(
             typeInfo,
             stack.minus(0),
             locals,
@@ -64,8 +64,8 @@ public record LlvmCompilerContext(
         ).toResult(stack.get(0));
     }
 
-    public LlvmCompilerContext addLocal(String name, LlvmOperand value) {
-        return new LlvmCompilerContext(
+    public LlvmCodeGenContext addLocal(String name, LlvmOperand value) {
+        return new LlvmCodeGenContext(
             typeInfo,
             stack,
             locals.plus(name, value),
@@ -86,8 +86,8 @@ public record LlvmCompilerContext(
         }
     }
 
-    public LlvmCompilerContext addInstruction(LlvmInstruction instruction) {
-        return new LlvmCompilerContext(
+    public LlvmCodeGenContext addInstruction(LlvmInstruction instruction) {
+        return new LlvmCodeGenContext(
             typeInfo,
             stack,
             locals,
@@ -98,10 +98,10 @@ public record LlvmCompilerContext(
         );
     }
 
-    public LlvmCompilerContext addTerminatorInstruction(
+    public LlvmCodeGenContext addTerminatorInstruction(
         LlvmTerminatorInstruction terminatorInstruction
     ) {
-        return new LlvmCompilerContext(
+        return new LlvmCodeGenContext(
             typeInfo,
             stack,
             locals,
@@ -116,7 +116,7 @@ public record LlvmCompilerContext(
         );
     }
 
-    public LlvmCompilerResult<LlvmGlobalDefinition> addGlobalDefinition(
+    public LlvmCodeGenResult<LlvmGlobalDefinition> addGlobalDefinition(
         LlvmGlobalDefinitionBuilder builder
     ) {
         var globalDefinition = new LlvmGlobalDefinition(
@@ -131,8 +131,8 @@ public record LlvmCompilerContext(
         return addTopLevelEntity(globalDefinition).toResult(globalDefinition);
     }
 
-    public LlvmCompilerContext addTopLevelEntity(LlvmTopLevelEntity topLevelEntity) {
-        return new LlvmCompilerContext(
+    public LlvmCodeGenContext addTopLevelEntity(LlvmTopLevelEntity topLevelEntity) {
+        return new LlvmCodeGenContext(
             typeInfo,
             stack,
             locals,
@@ -143,16 +143,16 @@ public record LlvmCompilerContext(
         );
     }
 
-    public String generateTopLevelEntityName(LlvmCompilerTopLevelEntitySpace space, String name) {
+    public String generateTopLevelEntityName(LlvmCodeGenTopLevelEntitySpace space, String name) {
         return generateTopLevelEntityName(space, Optional.of(name));
     }
 
-    private String generateTopLevelEntityName(LlvmCompilerTopLevelEntitySpace space) {
+    private String generateTopLevelEntityName(LlvmCodeGenTopLevelEntitySpace space) {
         return generateTopLevelEntityName(space, Optional.empty());
     }
 
     private String generateTopLevelEntityName(
-        LlvmCompilerTopLevelEntitySpace space,
+        LlvmCodeGenTopLevelEntitySpace space,
         Optional<String> name
     ) {
         return NameAllocator.generateName(
@@ -170,25 +170,25 @@ public record LlvmCompilerContext(
         return topLevelEntitiesByName.toValues();
     }
 
-    public LlvmCompilerResult<LlvmVariableLocal> generateVariableLocal(
-        LlvmCompilerLocalVariableSpace space
+    public LlvmCodeGenResult<LlvmVariableLocal> generateVariableLocal(
+        LlvmCodeGenLocalVariableSpace space
     ) {
         return generateVariableLocal(space, Optional.empty());
     }
 
-    public LlvmCompilerResult<LlvmVariableLocal> generateVariableLocal(
-        LlvmCompilerLocalVariableSpace space,
+    public LlvmCodeGenResult<LlvmVariableLocal> generateVariableLocal(
+        LlvmCodeGenLocalVariableSpace space,
         String name
     ) {
         return generateVariableLocal(space, Optional.of(name));
     }
 
-    private LlvmCompilerResult<LlvmVariableLocal> generateVariableLocal(
-        LlvmCompilerLocalVariableSpace space,
+    private LlvmCodeGenResult<LlvmVariableLocal> generateVariableLocal(
+        LlvmCodeGenLocalVariableSpace space,
         Optional<String> name
     ) {
         var result = localVariableNames.generateName(space, name);
-        return new LlvmCompilerContext(
+        return new LlvmCodeGenContext(
             typeInfo,
             stack,
             locals,
@@ -199,12 +199,12 @@ public record LlvmCompilerContext(
         ).toResult(new LlvmVariableLocal(result.name()));
     }
 
-    public <T> LlvmCompilerResult<T> toResult(T value) {
-        return new LlvmCompilerResult<>(value, this);
+    public <T> LlvmCodeGenResult<T> toResult(T value) {
+        return new LlvmCodeGenResult<>(value, this);
     }
 
-    public LlvmCompilerContext enterFunction() {
-        return new LlvmCompilerContext(
+    public LlvmCodeGenContext enterFunction() {
+        return new LlvmCodeGenContext(
             typeInfo,
             Empty.stack(),
             Empty.map(),
@@ -215,10 +215,10 @@ public record LlvmCompilerContext(
         );
     }
 
-    public LlvmCompilerResult<List<LlvmBasicBlock>> exitFunction(
-        LlvmCompilerContext functionContext
+    public LlvmCodeGenResult<List<LlvmBasicBlock>> exitFunction(
+        LlvmCodeGenContext functionContext
     ) {
-        return new LlvmCompilerContext(
+        return new LlvmCodeGenContext(
             typeInfo,
             stack,
             locals,
diff --git a/src/main/java/org/shedlang/compiler/backends/llvm/LlvmCompilerLocalVariableSpace.java b/src/main/java/org/shedlang/compiler/backends/llvm/LlvmCodeGenLocalVariableSpace.java
index 70cd13bc..1da74d57 100644
--- a/src/main/java/org/shedlang/compiler/backends/llvm/LlvmCompilerLocalVariableSpace.java
+++ b/src/main/java/org/shedlang/compiler/backends/llvm/LlvmCodeGenLocalVariableSpace.java
@@ -1,6 +1,6 @@
 package org.shedlang.compiler.backends.llvm;
 
-public enum LlvmCompilerLocalVariableSpace {
+public enum LlvmCodeGenLocalVariableSpace {
     CLOSURE_VALUE("closureValue"),
     CLOSURE_POINTER("closurePointer"),
     CLOSURE_FUNCTION_POINTER("closureFunctionPointer"),
@@ -18,7 +18,7 @@ public enum LlvmCompilerLocalVariableSpace {
 
     private final String name;
 
-    LlvmCompilerLocalVariableSpace(String name) {
+    LlvmCodeGenLocalVariableSpace(String name) {
         this.name = name;
     }
 
diff --git a/src/main/java/org/shedlang/compiler/backends/llvm/LlvmCompilerNamespaces.java b/src/main/java/org/shedlang/compiler/backends/llvm/LlvmCodeGenNamespaces.java
index 7432ac35..1c60bab9 100644
--- a/src/main/java/org/shedlang/compiler/backends/llvm/LlvmCompilerNamespaces.java
+++ b/src/main/java/org/shedlang/compiler/backends/llvm/LlvmCodeGenNamespaces.java
@@ -18,8 +18,8 @@ import java.util.List;
 import java.util.Optional;
 import java.util.stream.IntStream;
 
-public class LlvmCompilerNamespaces {
-    private LlvmCompilerNamespaces() {
+public class LlvmCodeGenNamespaces {
+    private LlvmCodeGenNamespaces() {
     }
 
     private static LlvmTypePointer typeNamespacePointer(NamespaceTypeInfo namespaceTypeInfo) {
@@ -29,14 +29,14 @@ public class LlvmCompilerNamespaces {
     private static LlvmType typeNamespaceStruct(NamespaceTypeInfo namespaceTypeInfo) {
         return new LlvmTypeStructure(Collections.nCopies(
             namespaceTypeInfo.fieldCount(),
-            LlvmCompilerTypes.VALUE_TYPE
+            LlvmCodeGenTypes.VALUE_TYPE
         ));
     }
 
     private static LlvmOperand operandNamespaceValue(NamespaceName namespaceName) {
         return new LlvmOperandPtrToInt(
             operandNamespaceStruct(namespaceName),
-            LlvmCompilerTypes.VALUE_TYPE
+            LlvmCodeGenTypes.VALUE_TYPE
         );
     }
 
@@ -64,22 +64,22 @@ public class LlvmCompilerNamespaces {
         return String.join("_", namespaceName.parts());
     }
 
-    public static LlvmCompilerResult<LlvmOperand> importValue(
+    public static LlvmCodeGenResult<LlvmOperand> importValue(
         NamespaceName namespaceName,
-        LlvmCompilerContext context
+        LlvmCodeGenContext context
     ) {
         var importName = globalNameNamespaceImport(namespaceName);
 
         if (!context.hasTopLevelEntity(importName)) {
             context = context.addTopLevelEntity(new LlvmFunctionDeclaration(
                 importName,
-                LlvmCompilerTypes.VALUE_TYPE,
+                LlvmCodeGenTypes.VALUE_TYPE,
                 List.of()
             ));
         }
 
         var namespaceResult = context.generateVariableLocal(
-            LlvmCompilerLocalVariableSpace.NAMESPACE,
+            LlvmCodeGenLocalVariableSpace.NAMESPACE,
             namespaceNameToLlvmIdentifier(namespaceName)
         );
         var namespace = namespaceResult.value();
@@ -87,15 +87,15 @@ public class LlvmCompilerNamespaces {
 
         return context.addInstruction(new LlvmCall(
             namespace,
-            LlvmCompilerTypes.VALUE_TYPE,
+            LlvmCodeGenTypes.VALUE_TYPE,
             new LlvmVariableGlobal(importName),
             List.of()
         )).toResult(namespace);
     }
 
-    public static LlvmCompilerContext define(
+    public static LlvmCodeGenContext define(
         NamespaceName namespaceName,
-        LlvmCompilerContext context
+        LlvmCodeGenContext context
     ) {
         context = context.addInstruction(new LlvmStore(
             LlvmTypes.INT_1,
@@ -113,7 +113,7 @@ public class LlvmCompilerNamespaces {
 
         var namespaceImportFunction = new LlvmFunctionDefinition(
             globalNameNamespaceImport(namespaceName),
-            LlvmCompilerTypes.VALUE_TYPE,
+            LlvmCodeGenTypes.VALUE_TYPE,
             List.of(),
             List.of(
                 new LlvmBasicBlock(
@@ -147,7 +147,7 @@ public class LlvmCompilerNamespaces {
                     Optional.of("inited"),
                     List.of(),
                     new LlvmReturn(
-                        LlvmCompilerTypes.VALUE_TYPE,
+                        LlvmCodeGenTypes.VALUE_TYPE,
                         operandNamespaceValue(namespaceName)
                     )
                 )
@@ -187,7 +187,7 @@ public class LlvmCompilerNamespaces {
             Optional.of(new LlvmOperandStructure(
                 IntStream.range(0, namespaceTypeInfo.fieldCount())
                     .mapToObj(ignored -> new LlvmTypedOperand(
-                        LlvmCompilerTypes.VALUE_TYPE,
+                        LlvmCodeGenTypes.VALUE_TYPE,
                         new LlvmOperandInt(0)
                     ))
                     .toList()
@@ -198,16 +198,16 @@ public class LlvmCompilerNamespaces {
         );
     }
 
-    public static LlvmCompilerContext fieldStore(
+    public static LlvmCodeGenContext fieldStore(
         NamespaceName namespaceName,
         String fieldName,
         LlvmOperand fieldValue,
-        LlvmCompilerContext context
+        LlvmCodeGenContext context
     ) {
         var namespaceTypeInfo = context.typeInfo().namespaceTypeInfo(namespaceName);
 
         var fieldPointerResult = context.generateVariableLocal(
-            LlvmCompilerLocalVariableSpace.FIELD_POINTER,
+            LlvmCodeGenLocalVariableSpace.FIELD_POINTER,
             fieldName
         );
         var fieldPointer = fieldPointerResult.value();
@@ -222,22 +222,22 @@ public class LlvmCompilerNamespaces {
                 LlvmTypedOperand.structureIndex(namespaceTypeInfo.fieldIndex(fieldName))
             )
         )).addInstruction(new LlvmStore(
-            LlvmCompilerTypes.VALUE_TYPE,
+            LlvmCodeGenTypes.VALUE_TYPE,
             fieldValue,
             fieldPointer
         ));
     }
 
-    public static LlvmCompilerResult<LlvmVariableLocal> fieldLoad(
+    public static LlvmCodeGenResult<LlvmVariableLocal> fieldLoad(
         NamespaceName namespaceName,
         LlvmOperand namespace,
         String fieldName,
-        LlvmCompilerContext context
+        LlvmCodeGenContext context
     ) {
         var namespaceTypeInfo = context.typeInfo().namespaceTypeInfo(namespaceName);
 
         var namespaceStructPointerResult = context.generateVariableLocal(
-            LlvmCompilerLocalVariableSpace.NAMESPACE_STRUCT_POINTER,
+            LlvmCodeGenLocalVariableSpace.NAMESPACE_STRUCT_POINTER,
             String.join("_", namespaceName.parts())
         );
         var namespaceStructPointer = namespaceStructPointerResult.value();
@@ -245,19 +245,19 @@ public class LlvmCompilerNamespaces {
 
         context = context.addInstruction(new LlvmIntToPtr(
             namespaceStructPointer,
-            LlvmCompilerTypes.VALUE_TYPE,
+            LlvmCodeGenTypes.VALUE_TYPE,
             namespace
         ));
 
         var fieldPointerResult = context.generateVariableLocal(
-            LlvmCompilerLocalVariableSpace.FIELD_POINTER,
+            LlvmCodeGenLocalVariableSpace.FIELD_POINTER,
             fieldName
         );
         var fieldPointer = fieldPointerResult.value();
         context = fieldPointerResult.context();
 
         var fieldResult = context.generateVariableLocal(
-            LlvmCompilerLocalVariableSpace.FIELD,
+            LlvmCodeGenLocalVariableSpace.FIELD,
             fieldName
         );
         var field = fieldResult.value();
@@ -273,7 +273,7 @@ public class LlvmCompilerNamespaces {
             )
         )).addInstruction(new LlvmLoad(
             field,
-            LlvmCompilerTypes.VALUE_TYPE,
+            LlvmCodeGenTypes.VALUE_TYPE,
             fieldPointer
         )).toResult(field);
     }
diff --git a/src/main/java/org/shedlang/compiler/backends/llvm/LlvmCodeGenResult.java b/src/main/java/org/shedlang/compiler/backends/llvm/LlvmCodeGenResult.java
new file mode 100644
index 00000000..f52c05ec
--- /dev/null
+++ b/src/main/java/org/shedlang/compiler/backends/llvm/LlvmCodeGenResult.java
@@ -0,0 +1,7 @@
+package org.shedlang.compiler.backends.llvm;
+
+public record LlvmCodeGenResult<T>(
+    T value,
+    LlvmCodeGenContext context
+) {
+}
diff --git a/src/main/java/org/shedlang/compiler/backends/llvm/LlvmCompilerRuntime.java b/src/main/java/org/shedlang/compiler/backends/llvm/LlvmCodeGenRuntime.java
index 2a9d842a..3e9c86de 100644
--- a/src/main/java/org/shedlang/compiler/backends/llvm/LlvmCompilerRuntime.java
+++ b/src/main/java/org/shedlang/compiler/backends/llvm/LlvmCodeGenRuntime.java
@@ -10,15 +10,15 @@ import org.shedlang.compiler.backends.llvm.ir.ast.types.LlvmTypes;
 
 import java.util.List;
 
-public class LlvmCompilerRuntime {
-    private LlvmCompilerRuntime() {
+public class LlvmCodeGenRuntime {
+    private LlvmCodeGenRuntime() {
     }
 
-    public static LlvmCompilerContext callAlloc(
+    public static LlvmCodeGenContext callAlloc(
         LlvmVariable target,
         LlvmType type,
         LlvmOperand size,
-        LlvmCompilerContext context
+        LlvmCodeGenContext context
     ) {
         return context.addInstruction(new LlvmCall(
             target,
diff --git a/src/main/java/org/shedlang/compiler/backends/llvm/LlvmCompilerStrings.java b/src/main/java/org/shedlang/compiler/backends/llvm/LlvmCodeGenStrings.java
index f5df0ce4..8165e3c8 100644
--- a/src/main/java/org/shedlang/compiler/backends/llvm/LlvmCompilerStrings.java
+++ b/src/main/java/org/shedlang/compiler/backends/llvm/LlvmCodeGenStrings.java
@@ -10,8 +10,8 @@ import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
 import java.util.List;
 
-public class LlvmCompilerStrings {
-    private LlvmCompilerStrings() {
+public class LlvmCodeGenStrings {
+    private LlvmCodeGenStrings() {
     }
 
     public static final LlvmType TYPE_STRING_LENGTH = LlvmTypes.INT_64;
@@ -31,7 +31,7 @@ public class LlvmCompilerStrings {
         return LlvmTypes.pointer(typeStringStruct(size));
     }
 
-    public static LlvmCompilerResult<LlvmGlobalDefinition> defineString(String value, LlvmCompilerContext context) {
+    public static LlvmCodeGenResult<LlvmGlobalDefinition> defineString(String value, LlvmCodeGenContext context) {
         var codeUnits = value.getBytes(StandardCharsets.UTF_8);
 
         var codeUnitOperands = new ArrayList<LlvmOperand>();
@@ -51,7 +51,7 @@ public class LlvmCompilerStrings {
         ));
 
         var globalDefinitionBuilder = LlvmGlobalDefinitionBuilder.builder()
-            .namePrefix(LlvmCompilerTopLevelEntitySpace.STRING)
+            .namePrefix(LlvmCodeGenTopLevelEntitySpace.STRING)
             .type(typeStringStruct(codeUnits.length))
             .value(llvmValue)
             .isPrivate(true)
@@ -64,7 +64,7 @@ public class LlvmCompilerStrings {
     public static LlvmOperand operandAsShedObject(LlvmGlobalDefinition globalDefinition) {
         return new LlvmOperandPtrToInt(
             new LlvmVariableGlobal(globalDefinition.name()),
-            LlvmCompilerTypes.VALUE_TYPE
+            LlvmCodeGenTypes.VALUE_TYPE
         );
     }
 }
diff --git a/src/main/java/org/shedlang/compiler/backends/llvm/LlvmCompilerTopLevelEntitySpace.java b/src/main/java/org/shedlang/compiler/backends/llvm/LlvmCodeGenTopLevelEntitySpace.java
index 87b0a60b..a65ae7a6 100644
--- a/src/main/java/org/shedlang/compiler/backends/llvm/LlvmCompilerTopLevelEntitySpace.java
+++ b/src/main/java/org/shedlang/compiler/backends/llvm/LlvmCodeGenTopLevelEntitySpace.java
@@ -1,12 +1,12 @@
 package org.shedlang.compiler.backends.llvm;
 
-public enum LlvmCompilerTopLevelEntitySpace {
+public enum LlvmCodeGenTopLevelEntitySpace {
     FUNCTION("fun"),
     STRING("string");
 
     private final String name;
 
-    LlvmCompilerTopLevelEntitySpace(String name) {
+    LlvmCodeGenTopLevelEntitySpace(String name) {
         this.name = name;
     }
 
diff --git a/src/main/java/org/shedlang/compiler/backends/llvm/LlvmCompilerTypes.java b/src/main/java/org/shedlang/compiler/backends/llvm/LlvmCodeGenTypes.java
index 3623d829..d8c18bed 100644
--- a/src/main/java/org/shedlang/compiler/backends/llvm/LlvmCompilerTypes.java
+++ b/src/main/java/org/shedlang/compiler/backends/llvm/LlvmCodeGenTypes.java
@@ -3,8 +3,8 @@ package org.shedlang.compiler.backends.llvm;
 import org.shedlang.compiler.backends.llvm.ir.ast.types.LlvmTypeScalar;
 import org.shedlang.compiler.backends.llvm.ir.ast.types.LlvmTypes;
 
-public class LlvmCompilerTypes {
-    private LlvmCompilerTypes() {
+public class LlvmCodeGenTypes {
+    private LlvmCodeGenTypes() {
     }
 
     public static final LlvmTypeScalar VALUE_TYPE = LlvmTypes.INT_64;
diff --git a/src/main/java/org/shedlang/compiler/backends/llvm/LlvmCompilerResult.java b/src/main/java/org/shedlang/compiler/backends/llvm/LlvmCompilerResult.java
deleted file mode 100644
index b0d7e1b8..00000000
--- a/src/main/java/org/shedlang/compiler/backends/llvm/LlvmCompilerResult.java
+++ /dev/null
@@ -1,7 +0,0 @@
-package org.shedlang.compiler.backends.llvm;
-
-public record LlvmCompilerResult<T>(
-    T value,
-    LlvmCompilerContext context
-) {
-}
diff --git a/src/main/java/org/shedlang/compiler/backends/llvm/LlvmGlobalDefinitionBuilder.java b/src/main/java/org/shedlang/compiler/backends/llvm/LlvmGlobalDefinitionBuilder.java
index 42c692c6..b559c315 100644
--- a/src/main/java/org/shedlang/compiler/backends/llvm/LlvmGlobalDefinitionBuilder.java
+++ b/src/main/java/org/shedlang/compiler/backends/llvm/LlvmGlobalDefinitionBuilder.java
@@ -6,7 +6,7 @@ import org.shedlang.compiler.backends.llvm.ir.ast.types.LlvmType;
 import java.util.Optional;
 
 public record LlvmGlobalDefinitionBuilder(
-    Optional<LlvmCompilerTopLevelEntitySpace> namePrefix,
+    Optional<LlvmCodeGenTopLevelEntitySpace> namePrefix,
     Optional<LlvmType> type,
     Optional<LlvmOperand> value,
     boolean constant,
@@ -24,7 +24,7 @@ public record LlvmGlobalDefinitionBuilder(
         );
     }
 
-    public LlvmGlobalDefinitionBuilder namePrefix(LlvmCompilerTopLevelEntitySpace namePrefix) {
+    public LlvmGlobalDefinitionBuilder namePrefix(LlvmCodeGenTopLevelEntitySpace namePrefix) {
         return new LlvmGlobalDefinitionBuilder(
             Optional.of(namePrefix),
             this.type,
diff --git a/src/main/java/org/shedlang/compiler/backends/llvm/LlvmSizeOf.java b/src/main/java/org/shedlang/compiler/backends/llvm/LlvmSizeOf.java
index 53d565f7..d59ea616 100644
--- a/src/main/java/org/shedlang/compiler/backends/llvm/LlvmSizeOf.java
+++ b/src/main/java/org/shedlang/compiler/backends/llvm/LlvmSizeOf.java
@@ -14,12 +14,12 @@ public class LlvmSizeOf {
     private LlvmSizeOf() {
     }
 
-    public static LlvmCompilerResult<LlvmOperand> sizeOf(LlvmType type, LlvmCompilerContext context) {
-        var sizePtrResult = context.generateVariableLocal(LlvmCompilerLocalVariableSpace.SIZE_PTR);
+    public static LlvmCodeGenResult<LlvmOperand> sizeOf(LlvmType type, LlvmCodeGenContext context) {
+        var sizePtrResult = context.generateVariableLocal(LlvmCodeGenLocalVariableSpace.SIZE_PTR);
         var sizePtr = sizePtrResult.value();
         context = sizePtrResult.context();
 
-        var sizeResult = context.generateVariableLocal(LlvmCompilerLocalVariableSpace.SIZE);
+        var sizeResult = context.generateVariableLocal(LlvmCodeGenLocalVariableSpace.SIZE);
         var size = sizeResult.value();
         context = sizeResult.context();