Remove protobuf

5 files changed, 0 insertions, 2042 deletions

diff --git a/src/main/java/org/shedlang/compiler/patio/serialization/PatioToProtobuf.java b/src/main/java/org/shedlang/compiler/patio/serialization/PatioToProtobuf.java
deleted file mode 100644
index cbddb85c..00000000
--- a/src/main/java/org/shedlang/compiler/patio/serialization/PatioToProtobuf.java
+++ /dev/null
@@ -1,1736 +0,0 @@
-package org.shedlang.compiler.patio.serialization;
-
-import org.shedlang.compiler.patio.*;
-import org.shedlang.compiler.patio.instructions.*;
-import org.shedlang.compiler.patio.operands.*;
-import org.shedlang.compiler.patio.protobuf.PatioProtobuf;
-import org.shedlang.compiler.patio.types.*;
-import org.shedlang.compiler.patio.values.*;
-import org.shedlang.compiler.sources.Source;
-
-import java.util.Optional;
-
-import static org.shedlang.compiler.sources.serialization.SourceToProtobuf.deserializeSource;
-import static org.shedlang.compiler.sources.serialization.SourceToProtobuf.serializeSource;
-
-public class PatioToProtobuf {
-    // == Compilation unit ==
-
-    public static PatioProtobuf.PatioCompilationUnit serializeCompilationUnit(
-        PatioCompilationUnit compilationUnit
-    ) {
-        var builder = PatioProtobuf.PatioCompilationUnit.newBuilder();
-
-        builder.setSource(serializeSource(compilationUnit.source(), Optional.empty()));
-
-        for (var element : compilationUnit.elements()) {
-            builder.addElements(serializeCompilationUnitElement(element, compilationUnit.source()));
-        }
-
-        return builder.build();
-    }
-
-    public static PatioCompilationUnit deserializeCompilationUnit(
-        PatioProtobuf.PatioCompilationUnit compilationUnitProtobuf
-    ) {
-        var source = deserializeSource(compilationUnitProtobuf.getSource(), Optional.empty());
-
-        return new PatioCompilationUnit(
-            compilationUnitProtobuf.getElementsList().stream()
-                .map(elementProtobuf -> deserializeCompilationUnitElement(elementProtobuf, source))
-                .toList(),
-            source
-        );
-    }
-
-    // == Compilation unit elements ==
-
-    public static PatioProtobuf.PatioCompilationUnitElement serializeCompilationUnitElement(
-        PatioCompilationUnitElement element,
-        Source parentSource
-    ) {
-        var builder = PatioProtobuf.PatioCompilationUnitElement.newBuilder();
-
-        switch (element) {
-            case PatioDataElementImmutableDefinition dataElementImmutableDefinition -> {
-                builder.setDataElementImmutableDefinition(
-                    serializeDataElementImmutableDefinition(dataElementImmutableDefinition, parentSource)
-                );
-            }
-            case PatioDataElementMutableDeclaration dataElementMutableDeclaration -> {
-                builder.setDataElementMutableDeclaration(
-                    serializeDataElementMutableDeclaration(dataElementMutableDeclaration, parentSource)
-                );
-            }
-            case PatioDataElementMutableDefinition dataElementMutableDefinition -> {
-                builder.setDataElementMutableDefinition(
-                    serializeDataElementMutableDefinition(dataElementMutableDefinition, parentSource)
-                );
-            }
-            case PatioExceptionTypeDefinition exceptionTypeDefinition -> {
-                builder.setExceptionTypeDefinition(
-                    serializeExceptionTypeDefinition(exceptionTypeDefinition, parentSource)
-                );
-            }
-            case PatioFunctionDeclaration functionDeclaration -> {
-                builder.setFunctionDeclaration(
-                    serializeFunctionDeclaration(functionDeclaration, parentSource)
-                );
-            }
-            case PatioFunctionDefinition functionDefinition -> {
-                builder.setFunctionDefinition(
-                    serializeFunctionDefinition(functionDefinition, parentSource)
-                );
-            }
-        }
-
-        return builder.build();
-    }
-
-    public static PatioCompilationUnitElement deserializeCompilationUnitElement(
-        PatioProtobuf.PatioCompilationUnitElement elementProtobuf,
-        Source parentSource
-    ) {
-        return switch (elementProtobuf.getValueCase()) {
-            case DATA_ELEMENT_IMMUTABLE_DEFINITION ->
-                deserializeDataElementImmutableDefinition(elementProtobuf.getDataElementImmutableDefinition(), parentSource);
-
-            case DATA_ELEMENT_MUTABLE_DECLARATION ->
-                deserializeDataElementMutationDeclaration(
-                    elementProtobuf.getDataElementMutableDeclaration(),
-                    parentSource
-                );
-
-            case DATA_ELEMENT_MUTABLE_DEFINITION ->
-                deserializeDataElementMutableDefinition(
-                    elementProtobuf.getDataElementMutableDefinition(),
-                    parentSource
-                );
-
-            case EXCEPTION_TYPE_DEFINITION ->
-                deserializeExceptionTypeDefinition(
-                    elementProtobuf.getExceptionTypeDefinition(),
-                    parentSource
-                );
-
-            case FUNCTION_DECLARATION ->
-                deserializeFunctionDeclaration(
-                    elementProtobuf.getFunctionDeclaration(),
-                    parentSource
-                );
-
-            case FUNCTION_DEFINITION ->
-                deserializeFunctionDefinition(
-                    elementProtobuf.getFunctionDefinition(),
-                    parentSource
-                );
-
-            case VALUE_NOT_SET ->
-                throw new UnsupportedOperationException("TODO");
-        };
-    }
-
-    private static PatioProtobuf.PatioDataElementImmutableDefinition serializeDataElementImmutableDefinition(
-        PatioDataElementImmutableDefinition element,
-        Source parentSource
-    ) {
-        var builder = PatioProtobuf.PatioDataElementImmutableDefinition.newBuilder();
-        builder.setSource(serializeSource(element.source(), parentSource));
-        builder.setName(element.name());
-        builder.setVisibility(serializeVisibility(element.visibility()));
-        builder.setValue(serializeDataValue(element.value()));
-        return builder.build();
-    }
-
-    private static PatioDataElementImmutableDefinition deserializeDataElementImmutableDefinition(
-        PatioProtobuf.PatioDataElementImmutableDefinition elementProtobuf,
-        Source parentSource
-    ) {
-        return new PatioDataElementImmutableDefinition(
-            elementProtobuf.getName(),
-            deserializeVisibility(elementProtobuf.getVisibility()),
-            deserializeDataValue(elementProtobuf.getValue()),
-            deserializeSource(elementProtobuf.getSource(), parentSource)
-        );
-    }
-
-    private static PatioProtobuf.PatioDataElementMutableDeclaration serializeDataElementMutableDeclaration(
-        PatioDataElementMutableDeclaration element,
-        Source parentSource
-    ) {
-        var builder = PatioProtobuf.PatioDataElementMutableDeclaration.newBuilder();
-        builder.setSource(serializeSource(element.source(), parentSource));
-        builder.setName(element.name());
-        builder.setLayout(serializeDataLayout(element.layout()));
-        return builder.build();
-    }
-
-    private static PatioDataElementMutableDeclaration deserializeDataElementMutationDeclaration(
-        PatioProtobuf.PatioDataElementMutableDeclaration elementProtobuf,
-        Source parentSource
-    ) {
-        return new PatioDataElementMutableDeclaration(
-            elementProtobuf.getName(),
-            deserializeDataLayout(elementProtobuf.getLayout()),
-            deserializeSource(elementProtobuf.getSource(), parentSource)
-        );
-    }
-
-
-    private static PatioProtobuf.PatioDataElementMutableDefinition serializeDataElementMutableDefinition(
-        PatioDataElementMutableDefinition element,
-        Source parentSource
-    ) {
-        var builder = PatioProtobuf.PatioDataElementMutableDefinition.newBuilder();
-        builder.setSource(serializeSource(element.source(), parentSource));
-        builder.setName(element.name());
-        builder.setVisibility(serializeVisibility(element.visibility()));
-        builder.setInitialValue(serializeDataValue(element.initialValue()));
-        return builder.build();
-    }
-
-    private static PatioDataElementMutableDefinition deserializeDataElementMutableDefinition(
-        PatioProtobuf.PatioDataElementMutableDefinition elementProtobuf,
-        Source parentSource
-    ) {
-        return new PatioDataElementMutableDefinition(
-            elementProtobuf.getName(),
-            deserializeVisibility(elementProtobuf.getVisibility()),
-            deserializeDataValue(elementProtobuf.getInitialValue()),
-            deserializeSource(elementProtobuf.getSource(), parentSource)
-        );
-    }
-
-    private static PatioProtobuf.PatioExceptionTypeDefinition serializeExceptionTypeDefinition(
-        PatioExceptionTypeDefinition element,
-        Source parentSource
-    ) {
-        var builder = PatioProtobuf.PatioExceptionTypeDefinition.newBuilder();
-        builder.setSource(serializeSource(element.source(), parentSource));
-        builder.setName(element.name());
-        builder.setValueType(serializeType(element.valueType()));
-        return builder.build();
-    }
-
-    private static PatioExceptionTypeDefinition deserializeExceptionTypeDefinition(
-        PatioProtobuf.PatioExceptionTypeDefinition elementProtobuf,
-        Source parentSource
-    ) {
-        return new PatioExceptionTypeDefinition(
-            elementProtobuf.getName(),
-            deserializeType(elementProtobuf.getValueType()),
-            deserializeSource(elementProtobuf.getSource(), parentSource)
-        );
-    }
-
-    private static PatioProtobuf.PatioFunctionDeclaration serializeFunctionDeclaration(
-        PatioFunctionDeclaration functionDeclaration,
-        Source parentSource
-    ) {
-        var builder = PatioProtobuf.PatioFunctionDeclaration.newBuilder();
-        builder.setSource(serializeSource(functionDeclaration.source(), parentSource));
-        builder.setName(functionDeclaration.name());
-        for (var param : functionDeclaration.params()) {
-            builder.addParams(serializeLocal(param));
-        }
-        builder.setReturnType(serializeType(functionDeclaration.returnType()));
-        return builder.build();
-    }
-
-    private static PatioFunctionDeclaration deserializeFunctionDeclaration(
-        PatioProtobuf.PatioFunctionDeclaration functionDeclarationProtobuf,
-        Source parentSource
-    ) {
-        return new PatioFunctionDeclaration(
-            functionDeclarationProtobuf.getName(),
-            functionDeclarationProtobuf.getParamsList().stream()
-                .map(PatioToProtobuf::deserializeLocal)
-                .toList(),
-            deserializeType(functionDeclarationProtobuf.getReturnType()),
-            deserializeSource(functionDeclarationProtobuf.getSource(), parentSource)
-        );
-    }
-
-    private static PatioProtobuf.PatioFunctionDefinition serializeFunctionDefinition(
-        PatioFunctionDefinition functionDefinition,
-        Source parentSource
-    ) {
-        var builder = PatioProtobuf.PatioFunctionDefinition.newBuilder();
-        builder.setSource(serializeSource(functionDefinition.source(), parentSource));
-        builder.setName(functionDefinition.name());
-        builder.setVisibility(serializeVisibility(functionDefinition.visibility()));
-        for (var param : functionDefinition.locals()) {
-            builder.addLocals(serializeLocal(param));
-        }
-        builder.setReturnType(serializeType(functionDefinition.returnType()));
-        for (var bodyInstruction : functionDefinition.body()) {
-            builder.addBody(serializeInstruction(bodyInstruction, functionDefinition.source()));
-        }
-        return builder.build();
-    }
-
-    private static PatioFunctionDefinition deserializeFunctionDefinition(
-        PatioProtobuf.PatioFunctionDefinition functionDefinitionProtobuf,
-        Source parentSource
-    ) {
-        var source = deserializeSource(functionDefinitionProtobuf.getSource(), parentSource);
-
-        return new PatioFunctionDefinition(
-            functionDefinitionProtobuf.getName(),
-            deserializeVisibility(functionDefinitionProtobuf.getVisibility()),
-            functionDefinitionProtobuf.getLocalsList().stream()
-                .map(PatioToProtobuf::deserializeLocal)
-                .toList(),
-            deserializeType(functionDefinitionProtobuf.getReturnType()),
-            functionDefinitionProtobuf.getBodyList().stream()
-                .map(bodyInstructionProtobuf -> deserializeInstruction(bodyInstructionProtobuf, source))
-                .toList(),
-            source
-        );
-    }
-
-    // == Locals ==
-
-    private static PatioProtobuf.PatioLocal serializeLocal(PatioLocal local) {
-        var builder = PatioProtobuf.PatioLocal.newBuilder();
-        builder.setName(local.name());
-        builder.setType(serializeType(local.type()));
-        builder.setLocalType(serializeLocalType(local.localType()));
-        return builder.build();
-    }
-
-    private static PatioLocal deserializeLocal(PatioProtobuf.PatioLocal localProtobuf) {
-        return new PatioLocal(
-            localProtobuf.getName(),
-            deserializeType(localProtobuf.getType()),
-            deserializeLocalType(localProtobuf.getLocalType())
-        );
-    }
-
-    private static PatioProtobuf.PatioLocalType serializeLocalType(PatioLocalType localType) {
-        return switch (localType) {
-            case PARAM ->
-                PatioProtobuf.PatioLocalType.PARAM;
-
-            case VAL ->
-                PatioProtobuf.PatioLocalType.VAL;
-
-            case VAR ->
-                PatioProtobuf.PatioLocalType.VAR;
-        };
-    }
-
-    private static PatioLocalType deserializeLocalType(PatioProtobuf.PatioLocalType localTypeProtobuf) {
-        return switch (localTypeProtobuf) {
-            case PARAM ->
-                PatioLocalType.PARAM;
-
-            case VAL ->
-                PatioLocalType.VAL;
-
-            case VAR ->
-                PatioLocalType.VAR;
-
-            case UNRECOGNIZED ->
-                throw new UnsupportedOperationException("TODO");
-        };
-    }
-
-    // == Visibility ==
-
-    private static PatioProtobuf.PatioVisibility serializeVisibility(PatioVisibility visibility) {
-        return switch (visibility) {
-            case PRIVATE ->
-                PatioProtobuf.PatioVisibility.PRIVATE;
-
-            case PUBLIC ->
-                PatioProtobuf.PatioVisibility.PUBLIC;
-        };
-    }
-
-    private static PatioVisibility deserializeVisibility(PatioProtobuf.PatioVisibility visibility) {
-        return switch (visibility) {
-            case PRIVATE ->
-                PatioVisibility.PRIVATE;
-
-            case PUBLIC ->
-                PatioVisibility.PUBLIC;
-
-            case UNRECOGNIZED ->
-                throw new UnsupportedOperationException("TODO");
-        };
-    }
-
-    // == Instructions ==
-
-    public static PatioProtobuf.PatioInstruction serializeInstruction(
-        PatioInstruction instruction,
-        Source parentSource
-    ) {
-        var builder = PatioProtobuf.PatioInstruction.newBuilder();
-
-        switch (instruction) {
-            case PatioBlock block -> {
-                builder.setBlock(serializeBlock(block, parentSource));
-            }
-
-            case PatioBoolToInt boolToInt -> {
-                builder.setBoolToInt(serializeBoolToInt(boolToInt, parentSource));
-            }
-
-            case PatioCall call -> {
-                builder.setCall(serializeCall(call, parentSource));
-            }
-
-            case PatioCallPointer callPointer -> {
-                builder.setCallPointer(serializeCallPointer(callPointer, parentSource));
-            }
-
-            case PatioDataPtrToInt dataPtrToInt -> {
-                builder.setDataPtrToInt(serializeDataPtrToInt(dataPtrToInt, parentSource));
-            }
-
-            case PatioIf if_ -> {
-                builder.setIf(serializeIf(if_, parentSource));
-            }
-
-            case PatioIntAdd intAdd -> {
-                builder.setIntAdd(serializeIntAdd(intAdd, parentSource));
-            }
-
-            case PatioIntEquals intEquals -> {
-                builder.setIntEquals(serializeIntEquals(intEquals, parentSource));
-            }
-
-            case PatioIntNotEqual intNotEqual -> {
-                builder.setIntNotEqual(serializeIntNotEqual(intNotEqual, parentSource));
-            }
-
-            case PatioIntSub intSub -> {
-                builder.setIntSub(serializeIntSub(intSub, parentSource));
-            }
-
-            case PatioIntToBool intToBool -> {
-                builder.setIntToBool(serializeIntToBool(intToBool, parentSource));
-            }
-
-            case PatioIntToDataPtr intToDataPtr -> {
-                builder.setIntToDataPtr(serializeIntToDataPtr(intToDataPtr, parentSource));
-            }
-
-            case PatioLocalStore localStore -> {
-                builder.setLocalStore(serializeLocalStore(localStore, parentSource));
-            }
-
-            case PatioLoop loop -> {
-                builder.setLoop(serializeLoop(loop, parentSource));
-            }
-
-            case PatioLoopBreak loopBreak -> {
-                builder.setLoopBreak(serializeLoopBreak(loopBreak, parentSource));
-            }
-
-            case PatioLoopContinue loopContinue -> {
-                builder.setLoopContinue(serializeLoopContinue(loopContinue, parentSource));
-            }
-
-            case PatioMemoryLoad memoryLoad -> {
-                builder.setMemoryLoad(serializeMemoryLoad(memoryLoad, parentSource));
-            }
-
-            case PatioMemoryStore memoryStore -> {
-                builder.setMemoryStore(serializeMemoryStore(memoryStore, parentSource));
-            }
-
-            case PatioResume resume -> {
-                builder.setResume(serializeResume(resume, parentSource));
-            }
-
-            case PatioReturn return_ -> {
-                builder.setReturn(serializeReturn(return_, parentSource));
-            }
-
-            case PatioReturnVoid returnVoid -> {
-                builder.setReturnVoid(serializeReturnVoid(returnVoid, parentSource));
-            }
-
-            case PatioSwitch switch_ -> {
-                builder.setSwitch(serializeSwitch(switch_, parentSource));
-            }
-
-            case PatioThrow throw_ -> {
-                builder.setThrow(serializeThrow(throw_, parentSource));
-            }
-
-            case PatioTry try_ -> {
-                builder.setTry(serializeTry(try_, parentSource));
-            }
-
-            case PatioUnreachable unreachable -> {
-                builder.setUnreachable(serializeUnreachable(unreachable, parentSource));
-            }
-
-            case PatioVarLoad varLoad -> {
-                builder.setVarLoad(serializeVarLoad(varLoad, parentSource));
-            }
-
-            case PatioVarStore varStore -> {
-                builder.setVarStore(serializeVarStore(varStore, parentSource));
-            }
-        }
-
-        return builder.build();
-    }
-
-    public static PatioInstruction deserializeInstruction(
-        PatioProtobuf.PatioInstruction instructionProtobuf,
-        Source parentSource
-    ) {
-        return switch (instructionProtobuf.getValueCase()) {
-            case BLOCK ->
-                deserializeBlock(instructionProtobuf.getBlock(), parentSource);
-
-            case BOOL_TO_INT ->
-                deserializeBoolToInt(instructionProtobuf.getBoolToInt(), parentSource);
-
-            case CALL ->
-                deserializeCall(instructionProtobuf.getCall(), parentSource);
-
-            case CALL_POINTER ->
-                deserializeCallPointer(instructionProtobuf.getCallPointer(), parentSource);
-
-            case DATA_PTR_TO_INT ->
-                deserializeDataPtrToInt(instructionProtobuf.getDataPtrToInt(), parentSource);
-
-            case IF ->
-                deserializeIf(instructionProtobuf.getIf(), parentSource);
-
-            case INT_ADD ->
-                deserializeIntAdd(instructionProtobuf.getIntAdd(), parentSource);
-
-            case INT_EQUALS ->
-                deserializeIntEquals(instructionProtobuf.getIntEquals(), parentSource);
-
-            case INT_NOT_EQUAL ->
-                deserializeIntNotEqual(instructionProtobuf.getIntNotEqual(), parentSource);
-
-            case INT_SUB ->
-                deserializeIntSub(instructionProtobuf.getIntSub(), parentSource);
-
-            case INT_TO_BOOL ->
-                deserializeIntToBool(instructionProtobuf.getIntToBool(), parentSource);
-
-            case INT_TO_DATA_PTR ->
-                deserializeIntToDataPtr(instructionProtobuf.getIntToDataPtr(), parentSource);
-
-            case LOCAL_STORE ->
-                deserializeLocalStore(instructionProtobuf.getLocalStore(), parentSource);
-
-            case LOOP ->
-                deserializeLoop(instructionProtobuf.getLoop(), parentSource);
-
-            case LOOP_BREAK ->
-                deserializeLoopBreak(instructionProtobuf.getLoopBreak(), parentSource);
-
-            case LOOP_CONTINUE ->
-                deserializeLoopContinue(instructionProtobuf.getLoopContinue(), parentSource);
-
-            case MEMORY_LOAD ->
-                deserializeMemoryLoad(instructionProtobuf.getMemoryLoad(), parentSource);
-
-            case MEMORY_STORE ->
-                deserializeMemoryStore(instructionProtobuf.getMemoryStore(), parentSource);
-
-            case RESUME ->
-                deserializeResume(instructionProtobuf.getResume(), parentSource);
-
-            case RETURN ->
-                deserializeReturn(instructionProtobuf.getReturn(), parentSource);
-
-            case RETURN_VOID ->
-                deserializeReturnVoid(instructionProtobuf.getReturnVoid(), parentSource);
-
-            case SWITCH ->
-                deserializeSwitch(instructionProtobuf.getSwitch(), parentSource);
-
-            case THROW ->
-                deserializeThrow(instructionProtobuf.getThrow(), parentSource);
-
-            case TRY ->
-                deserializeTry(instructionProtobuf.getTry(), parentSource);
-
-            case UNREACHABLE ->
-                deserializeUnreachable(instructionProtobuf.getUnreachable(), parentSource);
-
-            case VAR_LOAD ->
-                deserializeVarLoad(instructionProtobuf.getVarLoad(), parentSource);
-
-            case VAR_STORE ->
-                deserializeVarStore(instructionProtobuf.getVarStore(), parentSource);
-
-            case VALUE_NOT_SET ->
-                throw new UnsupportedOperationException("TODO");
-        };
-    }
-
-    private static PatioProtobuf.PatioBlock serializeBlock(
-        PatioBlock instruction,
-        Source parentSource
-    ) {
-        var builder = PatioProtobuf.PatioBlock.newBuilder();
-        builder.setSource(serializeSource(instruction.source(), parentSource));
-        for (var bodyInstruction : instruction.body()) {
-            builder.addBody(serializeInstruction(bodyInstruction, instruction.source()));
-        }
-        for (var result : instruction.results()) {
-            builder.addResults(serializeOperand(result));
-        }
-        return builder.build();
-    }
-
-    private static PatioBlock deserializeBlock(
-        PatioProtobuf.PatioBlock instructionProtobuf,
-        Source parentSource
-    ) {
-        var source = deserializeSource(instructionProtobuf.getSource(), parentSource);
-
-        return new PatioBlock(
-            instructionProtobuf.getBodyList().stream()
-                .map(bodyInstructionProtobuf -> deserializeInstruction(bodyInstructionProtobuf, source))
-                .toList(),
-            instructionProtobuf.getResultsList().stream()
-                .map(PatioToProtobuf::deserializeOperand)
-                .toList(),
-            source
-        );
-    }
-
-    private static PatioProtobuf.PatioBoolToInt serializeBoolToInt(
-        PatioBoolToInt instruction,
-        Source parentSource
-    ) {
-        var builder = PatioProtobuf.PatioBoolToInt.newBuilder();
-        builder.setSource(serializeSource(instruction.source(), parentSource));
-        builder.setDestination(serializeLocalRef(instruction.destination()));
-        builder.setValue(serializeOperand(instruction.value()));
-        return builder.build();
-    }
-
-    private static PatioBoolToInt deserializeBoolToInt(
-        PatioProtobuf.PatioBoolToInt instructionProtobuf,
-        Source parentSource
-    ) {
-        var source = deserializeSource(instructionProtobuf.getSource(), parentSource);
-
-        return new PatioBoolToInt(
-            deserializeLocalRef(instructionProtobuf.getDestination()),
-            deserializeOperand(instructionProtobuf.getValue()),
-            source
-        );
-    }
-
-    private static PatioProtobuf.PatioCall serializeCall(
-        PatioCall instruction,
-        Source parentSource
-    ) {
-        var builder = PatioProtobuf.PatioCall.newBuilder();
-        builder.setSource(serializeSource(instruction.source(), parentSource));
-        if (instruction.destination().isPresent()) {
-            builder.setDestination(serializeLocalRef(instruction.destination().get()));
-        }
-        builder.setFunctionName(instruction.functionName());
-        for (var arg : instruction.args()) {
-            builder.addArgs(serializeOperand(arg));
-        }
-        return builder.build();
-    }
-
-    private static PatioCall deserializeCall(
-        PatioProtobuf.PatioCall instructionProtobuf,
-        Source parentSource
-    ) {
-        var source = deserializeSource(instructionProtobuf.getSource(), parentSource);
-
-        return new PatioCall(
-            instructionProtobuf.hasDestination()
-                ? Optional.of(deserializeLocalRef(instructionProtobuf.getDestination()))
-                : Optional.<PatioLocalRef>empty(),
-            instructionProtobuf.getFunctionName(),
-            instructionProtobuf.getArgsList().stream()
-                .map(PatioToProtobuf::deserializeOperand)
-                .toList(),
-            source
-        );
-    }
-
-    private static PatioProtobuf.PatioCallPointer serializeCallPointer(
-        PatioCallPointer instruction,
-        Source parentSource
-    ) {
-        var builder = PatioProtobuf.PatioCallPointer.newBuilder();
-        builder.setSource(serializeSource(instruction.source(), parentSource));
-        builder.setDestination(serializeLocalRef(instruction.destination()));
-        builder.setFunctionPointer(serializeOperand(instruction.functionPointer()));
-        for (var arg : instruction.args()) {
-            builder.addArgs(serializeOperand(arg));
-        }
-        return builder.build();
-    }
-
-    private static PatioCallPointer deserializeCallPointer(
-        PatioProtobuf.PatioCallPointer instructionProtobuf,
-        Source parentSource
-    ) {
-        var source = deserializeSource(instructionProtobuf.getSource(), parentSource);
-
-        return new PatioCallPointer(
-            deserializeLocalRef(instructionProtobuf.getDestination()),
-            deserializeOperand(instructionProtobuf.getFunctionPointer()),
-            instructionProtobuf.getArgsList().stream()
-                .map(PatioToProtobuf::deserializeOperand)
-                .toList(),
-            source
-        );
-    }
-
-    private static PatioProtobuf.PatioDataPtrToInt serializeDataPtrToInt(
-        PatioDataPtrToInt instruction,
-        Source parentSource
-    ) {
-        var builder = PatioProtobuf.PatioDataPtrToInt.newBuilder();
-        builder.setSource(serializeSource(instruction.source(), parentSource));
-        builder.setDestination(serializeLocalRef(instruction.destination()));
-        builder.setValue(serializeOperand(instruction.value()));
-        return builder.build();
-    }
-
-    private static PatioDataPtrToInt deserializeDataPtrToInt(
-        PatioProtobuf.PatioDataPtrToInt instructionProtobuf,
-        Source parentSource
-    ) {
-        var source = deserializeSource(instructionProtobuf.getSource(), parentSource);
-
-        return new PatioDataPtrToInt(
-            deserializeLocalRef(instructionProtobuf.getDestination()),
-            deserializeOperand(instructionProtobuf.getValue()),
-            source
-        );
-    }
-
-    private static PatioProtobuf.PatioIf serializeIf(
-        PatioIf instruction,
-        Source parentSource
-    ) {
-        var builder = PatioProtobuf.PatioIf.newBuilder();
-        builder.setSource(serializeSource(instruction.source(), parentSource));
-        for (var destination : instruction.destinations()) {
-            builder.addDestinations(serializeLocalRef(destination));
-        }
-        builder.setCondition(serializeOperand(instruction.condition()));
-        builder.setTrueBody(serializeBlock(instruction.trueBody(), instruction.source()));
-        builder.setFalseBody(serializeBlock(instruction.falseBody(), instruction.source()));
-        return builder.build();
-    }
-
-    private static PatioIf deserializeIf(
-        PatioProtobuf.PatioIf instructionProtobuf,
-        Source parentSource
-    ) {
-        var source = deserializeSource(instructionProtobuf.getSource(), parentSource);
-
-        return new PatioIf(
-            instructionProtobuf.getDestinationsList().stream()
-                .map(PatioToProtobuf::deserializeLocalRef)
-                .toList(),
-            deserializeOperand(instructionProtobuf.getCondition()),
-            deserializeBlock(instructionProtobuf.getTrueBody(), source),
-            deserializeBlock(instructionProtobuf.getFalseBody(), source),
-            source
-        );
-    }
-
-    private static PatioProtobuf.PatioIntAdd serializeIntAdd(
-        PatioIntAdd instruction,
-        Source parentSource
-    ) {
-        var builder = PatioProtobuf.PatioIntAdd.newBuilder();
-        builder.setSource(serializeSource(instruction.source(), parentSource));
-        builder.setDestination(serializeLocalRef(instruction.destination()));
-        builder.setLeft(serializeOperand(instruction.left()));
-        builder.setRight(serializeOperand(instruction.right()));
-        return builder.build();
-    }
-
-    private static PatioIntAdd deserializeIntAdd(
-        PatioProtobuf.PatioIntAdd instructionProtobuf,
-        Source parentSource
-    ) {
-        var source = deserializeSource(instructionProtobuf.getSource(), parentSource);
-
-        return new PatioIntAdd(
-            deserializeLocalRef(instructionProtobuf.getDestination()),
-            deserializeOperand(instructionProtobuf.getLeft()),
-            deserializeOperand(instructionProtobuf.getRight()),
-            source
-        );
-    }
-
-    private static PatioProtobuf.PatioIntEquals serializeIntEquals(
-        PatioIntEquals instruction,
-        Source parentSource
-    ) {
-        var builder = PatioProtobuf.PatioIntEquals.newBuilder();
-        builder.setSource(serializeSource(instruction.source(), parentSource));
-        builder.setDestination(serializeLocalRef(instruction.destination()));
-        builder.setLeft(serializeOperand(instruction.left()));
-        builder.setRight(serializeOperand(instruction.right()));
-        return builder.build();
-    }
-
-    private static PatioIntEquals deserializeIntEquals(
-        PatioProtobuf.PatioIntEquals instructionProtobuf,
-        Source parentSource
-    ) {
-        var source = deserializeSource(instructionProtobuf.getSource(), parentSource);
-
-        return new PatioIntEquals(
-            deserializeLocalRef(instructionProtobuf.getDestination()),
-            deserializeOperand(instructionProtobuf.getLeft()),
-            deserializeOperand(instructionProtobuf.getRight()),
-            source
-        );
-    }
-
-    private static PatioProtobuf.PatioIntNotEqual serializeIntNotEqual(
-        PatioIntNotEqual instruction,
-        Source parentSource
-    ) {
-        var builder = PatioProtobuf.PatioIntNotEqual.newBuilder();
-        builder.setSource(serializeSource(instruction.source(), parentSource));
-        builder.setDestination(serializeLocalRef(instruction.destination()));
-        builder.setLeft(serializeOperand(instruction.left()));
-        builder.setRight(serializeOperand(instruction.right()));
-        return builder.build();
-    }
-
-    private static PatioIntNotEqual deserializeIntNotEqual(
-        PatioProtobuf.PatioIntNotEqual instructionProtobuf,
-        Source parentSource
-    ) {
-        var source = deserializeSource(instructionProtobuf.getSource(), parentSource);
-
-        return new PatioIntNotEqual(
-            deserializeLocalRef(instructionProtobuf.getDestination()),
-            deserializeOperand(instructionProtobuf.getLeft()),
-            deserializeOperand(instructionProtobuf.getRight()),
-            source
-        );
-    }
-
-    private static PatioProtobuf.PatioIntSub serializeIntSub(
-        PatioIntSub instruction,
-        Source parentSource
-    ) {
-        var builder = PatioProtobuf.PatioIntSub.newBuilder();
-        builder.setSource(serializeSource(instruction.source(), parentSource));
-        builder.setDestination(serializeLocalRef(instruction.destination()));
-        builder.setLeft(serializeOperand(instruction.left()));
-        builder.setRight(serializeOperand(instruction.right()));
-        return builder.build();
-    }
-
-    private static PatioIntSub deserializeIntSub(
-        PatioProtobuf.PatioIntSub instructionProtobuf,
-        Source parentSource
-    ) {
-        var source = deserializeSource(instructionProtobuf.getSource(), parentSource);
-
-        return new PatioIntSub(
-            deserializeLocalRef(instructionProtobuf.getDestination()),
-            deserializeOperand(instructionProtobuf.getLeft()),
-            deserializeOperand(instructionProtobuf.getRight()),
-            source
-        );
-    }
-
-    private static PatioProtobuf.PatioIntToBool serializeIntToBool(
-        PatioIntToBool instruction,
-        Source parentSource
-    ) {
-        var builder = PatioProtobuf.PatioIntToBool.newBuilder();
-        builder.setSource(serializeSource(instruction.source(), parentSource));
-        builder.setDestination(serializeLocalRef(instruction.destination()));
-        builder.setValue(serializeOperand(instruction.value()));
-        return builder.build();
-    }
-
-    private static PatioIntToBool deserializeIntToBool(
-        PatioProtobuf.PatioIntToBool instructionProtobuf,
-        Source parentSource
-    ) {
-        var source = deserializeSource(instructionProtobuf.getSource(), parentSource);
-
-        return new PatioIntToBool(
-            deserializeLocalRef(instructionProtobuf.getDestination()),
-            deserializeOperand(instructionProtobuf.getValue()),
-            source
-        );
-    }
-
-    private static PatioProtobuf.PatioIntToDataPtr serializeIntToDataPtr(
-        PatioIntToDataPtr instruction,
-        Source parentSource
-    ) {
-        var builder = PatioProtobuf.PatioIntToDataPtr.newBuilder();
-        builder.setSource(serializeSource(instruction.source(), parentSource));
-        builder.setDestination(serializeLocalRef(instruction.destination()));
-        builder.setValue(serializeOperand(instruction.value()));
-        return builder.build();
-    }
-
-    private static PatioIntToDataPtr deserializeIntToDataPtr(
-        PatioProtobuf.PatioIntToDataPtr instructionProtobuf,
-        Source parentSource
-    ) {
-        var source = deserializeSource(instructionProtobuf.getSource(), parentSource);
-
-        return new PatioIntToDataPtr(
-            deserializeLocalRef(instructionProtobuf.getDestination()),
-            deserializeOperand(instructionProtobuf.getValue()),
-            source
-        );
-    }
-
-    private static PatioProtobuf.PatioLocalStore serializeLocalStore(
-        PatioLocalStore instruction,
-        Source parentSource
-    ) {
-        var builder = PatioProtobuf.PatioLocalStore.newBuilder();
-        builder.setSource(serializeSource(instruction.source(), parentSource));
-        builder.setDestination(serializeLocalRef(instruction.destination()));
-        builder.setValue(serializeOperand(instruction.value()));
-        return builder.build();
-    }
-
-    private static PatioLocalStore deserializeLocalStore(
-        PatioProtobuf.PatioLocalStore instructionProtobuf,
-        Source parentSource
-    ) {
-        var source = deserializeSource(instructionProtobuf.getSource(), parentSource);
-
-        return new PatioLocalStore(
-            deserializeLocalRef(instructionProtobuf.getDestination()),
-            deserializeOperand(instructionProtobuf.getValue()),
-            source
-        );
-    }
-
-    private static PatioProtobuf.PatioLoop serializeLoop(
-        PatioLoop instruction,
-        Source parentSource
-    ) {
-        var builder = PatioProtobuf.PatioLoop.newBuilder();
-        builder.setSource(serializeSource(instruction.source(), parentSource));
-        for (var bodyInstruction : instruction.body()) {
-            builder.addBody(serializeInstruction(bodyInstruction, instruction.source()));
-        }
-        return builder.build();
-    }
-
-    private static PatioLoop deserializeLoop(
-        PatioProtobuf.PatioLoop instructionProtobuf,
-        Source parentSource
-    ) {
-        var source = deserializeSource(instructionProtobuf.getSource(), parentSource);
-
-        return new PatioLoop(
-            instructionProtobuf.getBodyList().stream()
-                .map(bodyInstructionProtobuf -> deserializeInstruction(bodyInstructionProtobuf, source))
-                .toList(),
-            source
-        );
-    }
-
-    private static PatioProtobuf.PatioLoopBreak serializeLoopBreak(
-        PatioLoopBreak instruction,
-        Source parentSource
-    ) {
-        var builder = PatioProtobuf.PatioLoopBreak.newBuilder();
-        builder.setSource(serializeSource(instruction.source(), parentSource));
-        return builder.build();
-    }
-
-    private static PatioLoopBreak deserializeLoopBreak(
-        PatioProtobuf.PatioLoopBreak instructionProtobuf,
-        Source parentSource
-    ) {
-        var source = deserializeSource(instructionProtobuf.getSource(), parentSource);
-
-        return new PatioLoopBreak(
-            source
-        );
-    }
-
-    private static PatioProtobuf.PatioLoopContinue serializeLoopContinue(
-        PatioLoopContinue instruction,
-        Source parentSource
-    ) {
-        var builder = PatioProtobuf.PatioLoopContinue.newBuilder();
-        builder.setSource(serializeSource(instruction.source(), parentSource));
-        return builder.build();
-    }
-
-    private static PatioLoopContinue deserializeLoopContinue(
-        PatioProtobuf.PatioLoopContinue instructionProtobuf,
-        Source parentSource
-    ) {
-        var source = deserializeSource(instructionProtobuf.getSource(), parentSource);
-
-        return new PatioLoopContinue(
-            source
-        );
-    }
-
-    private static PatioProtobuf.PatioMemoryLoad serializeMemoryLoad(
-        PatioMemoryLoad instruction,
-        Source parentSource
-    ) {
-        var builder = PatioProtobuf.PatioMemoryLoad.newBuilder();
-        builder.setSource(serializeSource(instruction.source(), parentSource));
-        builder.setDestination(serializeLocalRef(instruction.destination()));
-        builder.setPointer(serializeOperand(instruction.pointer()));
-        builder.setLayout(serializeDataLayout(instruction.layout()));
-        builder.addAllOffset(instruction.offset());
-        return builder.build();
-    }
-
-    private static PatioMemoryLoad deserializeMemoryLoad(
-        PatioProtobuf.PatioMemoryLoad instructionProtobuf,
-        Source parentSource
-    ) {
-        var source = deserializeSource(instructionProtobuf.getSource(), parentSource);
-
-        return new PatioMemoryLoad(
-            deserializeLocalRef(instructionProtobuf.getDestination()),
-            deserializeOperand(instructionProtobuf.getPointer()),
-            deserializeDataLayout(instructionProtobuf.getLayout()),
-            instructionProtobuf.getOffsetList(),
-            source
-        );
-    }
-
-    private static PatioProtobuf.PatioMemoryStore serializeMemoryStore(
-        PatioMemoryStore instruction,
-        Source parentSource
-    ) {
-        var builder = PatioProtobuf.PatioMemoryStore.newBuilder();
-        builder.setSource(serializeSource(instruction.source(), parentSource));
-        builder.setPointer(serializeOperand(instruction.pointer()));
-        builder.setLayout(serializeDataLayout(instruction.layout()));
-        builder.addAllOffset(instruction.offset());
-        builder.setValue(serializeOperand(instruction.value()));
-        return builder.build();
-    }
-
-    private static PatioMemoryStore deserializeMemoryStore(
-        PatioProtobuf.PatioMemoryStore instructionProtobuf,
-        Source parentSource
-    ) {
-        var source = deserializeSource(instructionProtobuf.getSource(), parentSource);
-
-        return new PatioMemoryStore(
-            deserializeOperand(instructionProtobuf.getPointer()),
-            deserializeDataLayout(instructionProtobuf.getLayout()),
-            instructionProtobuf.getOffsetList(),
-            deserializeOperand(instructionProtobuf.getValue()),
-            source
-        );
-    }
-
-    private static PatioProtobuf.PatioResume serializeResume(
-        PatioResume instruction,
-        Source parentSource
-    ) {
-        var builder = PatioProtobuf.PatioResume.newBuilder();
-        builder.setSource(serializeSource(instruction.source(), parentSource));
-        builder.setValue(serializeOperand(instruction.value()));
-        return builder.build();
-    }
-
-    private static PatioResume deserializeResume(
-        PatioProtobuf.PatioResume instructionProtobuf,
-        Source parentSource
-    ) {
-        var source = deserializeSource(instructionProtobuf.getSource(), parentSource);
-
-        return new PatioResume(
-            deserializeOperand(instructionProtobuf.getValue()),
-            source
-        );
-    }
-
-    private static PatioProtobuf.PatioReturn serializeReturn(
-        PatioReturn instruction,
-        Source parentSource
-    ) {
-        var builder = PatioProtobuf.PatioReturn.newBuilder();
-        builder.setSource(serializeSource(instruction.source(), parentSource));
-        builder.setValue(serializeOperand(instruction.value()));
-        return builder.build();
-    }
-
-    private static PatioReturn deserializeReturn(
-        PatioProtobuf.PatioReturn instructionProtobuf,
-        Source parentSource
-    ) {
-        var source = deserializeSource(instructionProtobuf.getSource(), parentSource);
-
-        return new PatioReturn(
-            deserializeOperand(instructionProtobuf.getValue()),
-            source
-        );
-    }
-
-    private static PatioProtobuf.PatioReturnVoid serializeReturnVoid(
-        PatioReturnVoid instruction,
-        Source parentSource
-    ) {
-        var builder = PatioProtobuf.PatioReturnVoid.newBuilder();
-        builder.setSource(serializeSource(instruction.source(), parentSource));
-        return builder.build();
-    }
-
-    private static PatioReturnVoid deserializeReturnVoid(
-        PatioProtobuf.PatioReturnVoid instructionProtobuf,
-        Source parentSource
-    ) {
-        var source = deserializeSource(instructionProtobuf.getSource(), parentSource);
-
-        return new PatioReturnVoid(
-            source
-        );
-    }
-
-    private static PatioProtobuf.PatioSwitch serializeSwitch(
-        PatioSwitch instruction,
-        Source parentSource
-    ) {
-        var builder = PatioProtobuf.PatioSwitch.newBuilder();
-        builder.setSource(serializeSource(instruction.source(), parentSource));
-        for (var destination : instruction.destinations()) {
-            builder.addDestinations(serializeLocalRef(destination));
-        }
-        builder.setValue(serializeOperand(instruction.value()));
-        for (var case_ : instruction.cases()) {
-            builder.addCases(serializeSwitchCase(case_, instruction.source()));
-        }
-        builder.setDefaultBody(serializeBlock(instruction.defaultBody(), instruction.source()));
-        return builder.build();
-    }
-
-    private static PatioSwitch deserializeSwitch(
-        PatioProtobuf.PatioSwitch instructionProtobuf,
-        Source parentSource
-    ) {
-        var source = deserializeSource(instructionProtobuf.getSource(), parentSource);
-
-        return new PatioSwitch(
-            instructionProtobuf.getDestinationsList().stream()
-                .map(PatioToProtobuf::deserializeLocalRef)
-                .toList(),
-            deserializeOperand(instructionProtobuf.getValue()),
-            instructionProtobuf.getCasesList().stream()
-                .map(caseProtobuf -> deserializeSwitchCase(caseProtobuf, source))
-                .toList(),
-            deserializeBlock(instructionProtobuf.getDefaultBody(), source),
-            source
-        );
-    }
-
-    private static PatioProtobuf.PatioSwitchCase serializeSwitchCase(
-        PatioSwitch.Case case_,
-        Source parentSource
-    ) {
-        var builder = PatioProtobuf.PatioSwitchCase.newBuilder();
-        builder.setSource(serializeSource(case_.source(), parentSource));
-        builder.setValue(case_.value());
-        builder.setBody(serializeBlock(case_.body(), case_.source()));
-        return builder.build();
-    }
-
-    private static PatioSwitch.Case deserializeSwitchCase(
-        PatioProtobuf.PatioSwitchCase caseProtobuf,
-        Source parentSource
-    ) {
-        var source = deserializeSource(caseProtobuf.getSource(), parentSource);
-
-        return new PatioSwitch.Case(
-            caseProtobuf.getValue(),
-            deserializeBlock(caseProtobuf.getBody(), source),
-            source
-        );
-    }
-
-    private static PatioProtobuf.PatioThrow serializeThrow(
-        PatioThrow instruction,
-        Source parentSource
-    ) {
-        var builder = PatioProtobuf.PatioThrow.newBuilder();
-        builder.setSource(serializeSource(instruction.source(), parentSource));
-        builder.setExceptionTypeName(instruction.exceptionTypeName());
-        builder.setValue(serializeOperand(instruction.value()));
-        return builder.build();
-    }
-
-    private static PatioThrow deserializeThrow(
-        PatioProtobuf.PatioThrow instructionProtobuf,
-        Source parentSource
-    ) {
-        var source = deserializeSource(instructionProtobuf.getSource(), parentSource);
-
-        return new PatioThrow(
-            instructionProtobuf.getExceptionTypeName(),
-            deserializeOperand(instructionProtobuf.getValue()),
-            source
-        );
-    }
-
-    private static PatioProtobuf.PatioTry serializeTry(
-        PatioTry instruction,
-        Source parentSource
-    ) {
-        var builder = PatioProtobuf.PatioTry.newBuilder();
-        builder.setSource(serializeSource(instruction.source(), parentSource));
-        for (var destination : instruction.destinations()) {
-            builder.addDestinations(serializeLocalRef(destination));
-        }
-        for (var catchClause : instruction.catchClauses()) {
-            builder.addCatchClauses(serializeCatchClause(catchClause, instruction.source()));
-        }
-        builder.setBody(serializeBlock(instruction.body(), instruction.source()));
-        return builder.build();
-    }
-
-    private static PatioTry deserializeTry(
-        PatioProtobuf.PatioTry instructionProtobuf,
-        Source parentSource
-    ) {
-        var source = deserializeSource(instructionProtobuf.getSource(), parentSource);
-
-        return new PatioTry(
-            instructionProtobuf.getDestinationsList().stream()
-                .map(PatioToProtobuf::deserializeLocalRef)
-                .toList(),
-            instructionProtobuf.getCatchClausesList().stream()
-                .map(catchClauseProtobuf -> deserializeCatchClause(catchClauseProtobuf, source))
-                .toList(),
-            deserializeBlock(instructionProtobuf.getBody(), source),
-            source
-        );
-    }
-
-    private static PatioProtobuf.PatioCatchClause serializeCatchClause(
-        PatioCatchClause catchClause,
-        Source parentSource
-    ) {
-        var builder = PatioProtobuf.PatioCatchClause.newBuilder();
-        builder.setSource(serializeSource(catchClause.source(), parentSource));
-        builder.setExceptionTypeName(catchClause.exceptionTypeName());
-        builder.setDestination(serializeLocalRef(catchClause.destination()));
-        builder.setBody(serializeBlock(catchClause.body(), catchClause.source()));
-        return builder.build();
-    }
-
-    private static PatioCatchClause deserializeCatchClause(
-        PatioProtobuf.PatioCatchClause catchClauseProtobuf,
-        Source parentSource
-    ) {
-        var source = deserializeSource(catchClauseProtobuf.getSource(), parentSource);
-
-        return new PatioCatchClause(
-            catchClauseProtobuf.getExceptionTypeName(),
-            deserializeLocalRef(catchClauseProtobuf.getDestination()),
-            deserializeBlock(catchClauseProtobuf.getBody(), source),
-            source
-        );
-    }
-
-    private static PatioProtobuf.PatioUnreachable serializeUnreachable(
-        PatioUnreachable instruction,
-        Source parentSource
-    ) {
-        var builder = PatioProtobuf.PatioUnreachable.newBuilder();
-        builder.setSource(serializeSource(instruction.source(), parentSource));
-        return builder.build();
-    }
-
-    private static PatioUnreachable deserializeUnreachable(
-        PatioProtobuf.PatioUnreachable instructionProtobuf,
-        Source parentSource
-    ) {
-        var source = deserializeSource(instructionProtobuf.getSource(), parentSource);
-
-        return new PatioUnreachable(
-            source
-        );
-    }
-
-    private static PatioProtobuf.PatioVarLoad serializeVarLoad(
-        PatioVarLoad instruction,
-        Source parentSource
-    ) {
-        var builder = PatioProtobuf.PatioVarLoad.newBuilder();
-        builder.setSource(serializeSource(instruction.source(), parentSource));
-        builder.setDestination(serializeLocalRef(instruction.destination()));
-        builder.setVar(serializeLocalRef(instruction.var()));
-        return builder.build();
-    }
-
-    private static PatioVarLoad deserializeVarLoad(
-        PatioProtobuf.PatioVarLoad instructionProtobuf,
-        Source parentSource
-    ) {
-        var source = deserializeSource(instructionProtobuf.getSource(), parentSource);
-
-        return new PatioVarLoad(
-            deserializeLocalRef(instructionProtobuf.getDestination()),
-            deserializeLocalRef(instructionProtobuf.getVar()),
-            source
-        );
-    }
-
-    private static PatioProtobuf.PatioVarStore serializeVarStore(
-        PatioVarStore instruction,
-        Source parentSource
-    ) {
-        var builder = PatioProtobuf.PatioVarStore.newBuilder();
-        builder.setSource(serializeSource(instruction.source(), parentSource));
-        builder.setVar(serializeLocalRef(instruction.var()));
-        builder.setValue(serializeOperand(instruction.value()));
-        return builder.build();
-    }
-
-    private static PatioVarStore deserializeVarStore(
-        PatioProtobuf.PatioVarStore instructionProtobuf,
-        Source parentSource
-    ) {
-        var source = deserializeSource(instructionProtobuf.getSource(), parentSource);
-
-        return new PatioVarStore(
-            deserializeLocalRef(instructionProtobuf.getVar()),
-            deserializeOperand(instructionProtobuf.getValue()),
-            source
-        );
-    }
-
-    // == Operands ==
-
-    public static PatioProtobuf.PatioOperand serializeOperand(PatioOperand operand) {
-        var builder = PatioProtobuf.PatioOperand.newBuilder();
-
-        switch (operand) {
-            case PatioBoolConst boolConst -> {
-                var boolConstBuilder = builder.getBoolConstBuilder();
-                boolConstBuilder.setValue(boolConst.value());
-            }
-
-            case PatioByteConst byteConst -> {
-                var byteConstBuilder = builder.getByteConstBuilder();
-                byteConstBuilder.setValue(byteConst.value());
-            }
-
-            case PatioDataPtrConst dataPtrConst -> {
-                var dataPtrConstBuilder = builder.getDataPtrConstBuilder();
-                dataPtrConstBuilder.setValue(serializeDataPtrValue(dataPtrConst.value()));
-            }
-
-            case PatioFunctionPtrConst functionPtrConst -> {
-                var functionPtrConstBuilder = builder.getFunctionPtrConstBuilder();
-                functionPtrConstBuilder.setName(functionPtrConst.name());
-            }
-
-            case PatioIntConst intConst -> {
-                var intConstBuilder = builder.getIntConstBuilder();
-                intConstBuilder.setValue(serializeIntValue(intConst.value()));
-            }
-
-            case PatioInt32Const int32Const -> {
-                var int32ConstBuilder = builder.getInt32ConstBuilder();
-                int32ConstBuilder.setValue(serializeIntValue(int32Const.value()));
-            }
-
-            case PatioLocalRef localRef -> {
-                builder.setLocalRef(serializeLocalRef(localRef));
-            }
-        }
-
-        return builder.build();
-    }
-
-    public static PatioOperand deserializeOperand(PatioProtobuf.PatioOperand operandProtobuf) {
-        return switch (operandProtobuf.getValueCase()) {
-            case BOOL_CONST ->
-                new PatioBoolConst(operandProtobuf.getBoolConst().getValue());
-
-            case BYTE_CONST ->
-                new PatioByteConst((byte) operandProtobuf.getByteConst().getValue());
-
-            case DATA_PTR_CONST ->
-                new PatioDataPtrConst(
-                    deserializeDataPtrValue(operandProtobuf.getDataPtrConst().getValue())
-                );
-
-            case FUNCTION_PTR_CONST ->
-                new PatioFunctionPtrConst(operandProtobuf.getFunctionPtrConst().getName());
-
-            case INT_CONST ->
-                new PatioIntConst(
-                    deserializeIntValue(operandProtobuf.getIntConst().getValue())
-                );
-
-            case INT32_CONST ->
-                new PatioInt32Const(
-                    deserializeIntValue(operandProtobuf.getInt32Const().getValue())
-                );
-
-            case LOCAL_REF ->
-                deserializeLocalRef(operandProtobuf.getLocalRef());
-
-            case VALUE_NOT_SET ->
-                throw new UnsupportedOperationException("TODO");
-        };
-    }
-
-    private static PatioProtobuf.PatioLocalRef serializeLocalRef(PatioLocalRef localRef) {
-        var builder = PatioProtobuf.PatioLocalRef.newBuilder();
-        builder.setName(localRef.name());
-        return builder.build();
-    }
-
-    private static PatioLocalRef deserializeLocalRef(PatioProtobuf.PatioLocalRef localRefProtobuf) {
-        return new PatioLocalRef(localRefProtobuf.getName());
-    }
-
-    // == Data ptr values ==
-
-    public static PatioProtobuf.PatioDataPtrValue serializeDataPtrValue(PatioDataPtrValue value) {
-        var builder = PatioProtobuf.PatioDataPtrValue.newBuilder();
-
-        switch (value) {
-            case PatioDataPtrValueDataElement patioDataPtrValueDataElement -> {
-                var dataElementBuilder = PatioProtobuf.PatioDataPtrValueDataElement.newBuilder();
-                dataElementBuilder.setName(patioDataPtrValueDataElement.name());
-                builder.setDataElement(dataElementBuilder);
-            }
-
-            case PatioDataPtrValueNull patioDataPtrValueNull -> {
-                builder.setNull(PatioProtobuf.PatioDataPtrValueNull.newBuilder());
-            }
-        }
-
-        return builder.build();
-    }
-
-    public static PatioDataPtrValue deserializeDataPtrValue(PatioProtobuf.PatioDataPtrValue valueProtobuf) {
-        return switch (valueProtobuf.getValueCase()) {
-            case DATA_ELEMENT ->
-                new PatioDataPtrValueDataElement(valueProtobuf.getDataElement().getName());
-
-            case NULL ->
-                new PatioDataPtrValueNull();
-
-            case VALUE_NOT_SET ->
-                throw new UnsupportedOperationException("TODO");
-        };
-    }
-
-    // == Int values ==
-
-    public static PatioProtobuf.PatioIntValue serializeIntValue(PatioIntValue value) {
-        var builder = PatioProtobuf.PatioIntValue.newBuilder();
-
-        switch (value) {
-            case PatioIntValueByteOffsetOf patioIntValueByteOffsetOf -> {
-                var byteOffsetOfBuilder = PatioProtobuf.PatioIntValueByteOffsetOf.newBuilder();
-                byteOffsetOfBuilder.setLayout(serializeDataLayout(patioIntValueByteOffsetOf.layout()));
-                byteOffsetOfBuilder.addAllOffset(patioIntValueByteOffsetOf.offset());
-                builder.setByteOffsetOf(byteOffsetOfBuilder);
-            }
-
-            case PatioIntValueByteSizeOf patioIntValueByteSizeOf -> {
-                var byteSizeOfBuilder = PatioProtobuf.PatioIntValueByteSizeOf.newBuilder();
-                byteSizeOfBuilder.setLayout(serializeDataLayout(patioIntValueByteSizeOf.layout()));
-                builder.setByteSizeOf(byteSizeOfBuilder);
-            }
-
-            case PatioIntValueLiteral patioIntValueLiteral -> {
-                var literalBuilder = PatioProtobuf.PatioIntValueLiteral.newBuilder();
-                literalBuilder.setValue(patioIntValueLiteral.value());
-                builder.setLiteral(literalBuilder);
-            }
-        }
-
-        return builder.build();
-    }
-
-    public static PatioIntValue deserializeIntValue(PatioProtobuf.PatioIntValue valueProtobuf) {
-        return switch (valueProtobuf.getValueCase()) {
-            case BYTE_OFFSET_OF ->
-                new PatioIntValueByteOffsetOf(
-                    deserializeDataLayout(valueProtobuf.getByteOffsetOf().getLayout()),
-                    valueProtobuf.getByteOffsetOf().getOffsetList()
-                );
-
-            case BYTE_SIZE_OF ->
-                new PatioIntValueByteSizeOf(
-                    deserializeDataLayout(valueProtobuf.getByteSizeOf().getLayout())
-                );
-
-            case LITERAL ->
-                new PatioIntValueLiteral(valueProtobuf.getLiteral().getValue());
-
-            case VALUE_NOT_SET ->
-                throw new UnsupportedOperationException("TODO");
-        };
-    }
-
-    // == Types ==
-
-    public static PatioProtobuf.PatioType serializeType(PatioType type) {
-        var builder = PatioProtobuf.PatioType.newBuilder();
-
-        switch (type) {
-            case PatioBoolType patioBoolType ->
-                builder.getBoolBuilder();
-
-            case PatioByteType patioByteType ->
-                builder.getByteBuilder();
-
-            case PatioDataPtrType patioDataPtrType ->
-                builder.getDataPtrBuilder();
-
-            case PatioFunctionPtrType patioFunctionPtrType ->
-                builder.getFunctionPtrBuilder();
-
-            case PatioInt32Type patioInt32Type ->
-                builder.getInt32Builder();
-
-            case PatioIntType patioIntType ->
-                builder.getIntBuilder();
-
-            case PatioVoidType patioVoidType ->
-                builder.getVoidBuilder();
-        }
-
-        return builder.build();
-    }
-
-    public static PatioType deserializeType(PatioProtobuf.PatioType type) {
-        return switch (type.getValueCase()) {
-            case BOOL ->
-                PatioTypes.BOOL;
-
-            case BYTE ->
-                PatioTypes.BYTE;
-
-            case DATA_PTR ->
-                PatioTypes.DATA_PTR;
-
-            case FUNCTION_PTR ->
-                PatioTypes.FUNCTION_PTR;
-
-            case INT ->
-                PatioTypes.INT;
-
-            case INT32 ->
-                PatioTypes.INT32;
-
-            case VOID ->
-                PatioTypes.VOID;
-
-            case VALUE_NOT_SET ->
-                throw new UnsupportedOperationException("TODO");
-        };
-    }
-
-    // == Data layouts ==
-
-    public static PatioProtobuf.PatioDataLayout serializeDataLayout(PatioDataLayout layout) {
-        var builder = PatioProtobuf.PatioDataLayout.newBuilder();
-        switch (layout) {
-            case PatioDataLayoutArray patioDataLayoutArray -> {
-                var arrayBuilder = PatioProtobuf.PatioDataLayoutArray.newBuilder();
-                arrayBuilder.setElement(serializeDataLayout(patioDataLayoutArray.element()));
-                arrayBuilder.setSize(patioDataLayoutArray.size());
-                builder.setArray(arrayBuilder);
-            }
-
-            case PatioDataLayoutBool patioDataLayoutBool -> {
-                builder.setBool(PatioProtobuf.PatioDataLayoutBool.newBuilder().build());
-            }
-
-            case PatioDataLayoutByte patioDataLayoutByte -> {
-                builder.setByte(PatioProtobuf.PatioDataLayoutByte.newBuilder().build());
-            }
-
-            case PatioDataLayoutDataPtr patioDataLayoutDataPtr -> {
-                builder.setDataPtr(PatioProtobuf.PatioDataLayoutDataPtr.newBuilder().build());
-            }
-
-            case PatioDataLayoutFunctionPtr patioDataLayoutFunctionPtr -> {
-                builder.setFunctionPtr(PatioProtobuf.PatioDataLayoutFunctionPtr.newBuilder().build());
-            }
-
-            case PatioDataLayoutInt patioDataLayoutInt -> {
-                builder.setInt(PatioProtobuf.PatioDataLayoutInt.newBuilder().build());
-            }
-
-            case PatioDataLayoutInt32 patioDataLayoutInt32 -> {
-                builder.setInt32(PatioProtobuf.PatioDataLayoutInt32.newBuilder().build());
-            }
-
-            case PatioDataLayoutStruct patioDataLayoutStruct -> {
-                var structBuilder = PatioProtobuf.PatioDataLayoutStruct.newBuilder();
-                for (var element : patioDataLayoutStruct.elements()) {
-                    structBuilder.addElements(serializeDataLayout(element));
-                }
-                builder.setStruct(structBuilder);
-            }
-        }
-
-        return builder.build();
-    }
-
-    public static PatioDataLayout deserializeDataLayout(PatioProtobuf.PatioDataLayout layoutProtobuf) {
-        return switch (layoutProtobuf.getValueCase()) {
-            case ARRAY ->
-                PatioDataLayouts.array(
-                    deserializeDataLayout(layoutProtobuf.getArray().getElement()),
-                    layoutProtobuf.getArray().getSize()
-                );
-
-            case BOOL ->
-                PatioDataLayouts.BOOL;
-
-            case BYTE ->
-                PatioDataLayouts.BYTE;
-
-            case DATA_PTR ->
-                PatioDataLayouts.DATA_PTR;
-
-            case FUNCTION_PTR ->
-                PatioDataLayouts.FUNCTION_PTR;
-
-            case INT ->
-                PatioDataLayouts.INT;
-
-            case INT32 ->
-                PatioDataLayouts.INT32;
-
-            case STRUCT ->
-                PatioDataLayouts.struct(
-                    layoutProtobuf.getStruct().getElementsList().stream()
-                        .map(PatioToProtobuf::deserializeDataLayout)
-                        .toList()
-                );
-
-            case VALUE_NOT_SET -> {
-                throw new UnsupportedOperationException("TODO");
-            }
-        };
-    }
-
-    // == Data values ==
-
-    public static PatioProtobuf.PatioDataValue serializeDataValue(PatioDataValue value) {
-        var builder = PatioProtobuf.PatioDataValue.newBuilder();
-        switch (value) {
-            case PatioDataValueArray patioDataValueArray -> {
-                var arrayBuilder = PatioProtobuf.PatioDataValueArray.newBuilder();
-                arrayBuilder.setElementLayout(serializeDataLayout(patioDataValueArray.elementLayout()));
-                for (var element : patioDataValueArray.elements()) {
-                    arrayBuilder.addElements(serializeDataValue(element));
-                }
-                builder.setArray(arrayBuilder);
-            }
-
-            case PatioDataValueBool patioDataValueBool -> {
-                var boolBuilder = PatioProtobuf.PatioDataValueBool.newBuilder();
-                boolBuilder.setValue(patioDataValueBool.value());
-                builder.setBool(boolBuilder);
-            }
-
-            case PatioDataValueByte patioDataValueByte -> {
-                var byteBuilder = PatioProtobuf.PatioDataValueByte.newBuilder();
-                byteBuilder.setValue(patioDataValueByte.value());
-                builder.setByte(byteBuilder);
-            }
-
-            case PatioDataValueDataPtr patioDataValueDataPtr -> {
-                var dataPtrBuilder = PatioProtobuf.PatioDataValueDataPtr.newBuilder();
-                dataPtrBuilder.setValue(serializeDataPtrValue(patioDataValueDataPtr.value()));
-                builder.setDataPtr(dataPtrBuilder);
-            }
-
-            case PatioDataValueInt patioDataValueInt -> {
-                var intBuilder = PatioProtobuf.PatioDataValueInt.newBuilder();
-                intBuilder.setValue(serializeIntValue(patioDataValueInt.value()));
-                builder.setInt(intBuilder);
-            }
-
-            case PatioDataValueInt32 patioDataValueInt32 -> {
-                var int32Builder = PatioProtobuf.PatioDataValueInt32.newBuilder();
-                int32Builder.setValue(serializeIntValue(patioDataValueInt32.value()));
-                builder.setInt32(int32Builder);
-            }
-
-            case PatioDataValueStruct patioDataValueStruct -> {
-                var structBuilder = PatioProtobuf.PatioDataValueStruct.newBuilder();
-                for (var element : patioDataValueStruct.elements()) {
-                    structBuilder.addElements(serializeDataValue(element));
-                }
-                builder.setStruct(structBuilder);
-            }
-        }
-
-        return builder.build();
-    }
-
-    public static PatioDataValue deserializeDataValue(PatioProtobuf.PatioDataValue valueProtobuf) {
-        return switch (valueProtobuf.getValueCase()) {
-            case ARRAY ->
-                PatioDataValues.array(
-                    deserializeDataLayout(valueProtobuf.getArray().getElementLayout()),
-                    valueProtobuf.getArray().getElementsList().stream()
-                        .map(PatioToProtobuf::deserializeDataValue)
-                        .toList()
-                );
-
-            case BOOL ->
-                PatioDataValues.bool(valueProtobuf.getBool().getValue());
-
-            case BYTE ->
-                PatioDataValues.byte_(valueProtobuf.getByte().getValue());
-
-            case DATA_PTR ->
-                PatioDataValues.dataPtr(deserializeDataPtrValue(valueProtobuf.getDataPtr().getValue()));
-
-            case INT ->
-                PatioDataValues.int_(deserializeIntValue(valueProtobuf.getInt().getValue()));
-
-            case INT32 ->
-                PatioDataValues.int32(deserializeIntValue(valueProtobuf.getInt32().getValue()));
-
-            case STRUCT ->
-                PatioDataValues.struct(
-                    valueProtobuf.getStruct().getElementsList().stream()
-                        .map(PatioToProtobuf::deserializeDataValue)
-                        .toList()
-                );
-
-            case VALUE_NOT_SET -> {
-                throw new UnsupportedOperationException("TODO");
-            }
-        };
-    }
-}
diff --git a/src/main/java/org/shedlang/compiler/sources/serialization/SourceToProtobuf.java b/src/main/java/org/shedlang/compiler/sources/serialization/SourceToProtobuf.java
deleted file mode 100644
index 91a1464c..00000000
--- a/src/main/java/org/shedlang/compiler/sources/serialization/SourceToProtobuf.java
+++ /dev/null
@@ -1,128 +0,0 @@
-package org.shedlang.compiler.sources.serialization;
-
-import org.shedlang.compiler.sources.*;
-import org.shedlang.compiler.sources.protobuf.SourcesProtobuf;
-import org.zwobble.sourcetext.SourcePosition;
-import org.zwobble.sourcetext.SourceRange;
-import org.zwobble.sourcetext.SourceText;
-
-import java.util.Optional;
-
-public class SourceToProtobuf {
-    private SourceToProtobuf() {
-    }
-
-    public static SourcesProtobuf.Source serializeSource(
-        Source source,
-        Source parentSource
-    ) {
-        return serializeSource(source, Optional.of(parentSource));
-    }
-
-    public static SourcesProtobuf.Source serializeSource(
-        Source source,
-        Optional<Source> parentSource
-    ) {
-        var builder = SourcesProtobuf.Source.newBuilder();
-
-        switch (source) {
-            case NullSource nullSource -> {
-                builder.setNullSource(
-                    SourcesProtobuf.NullSource.newBuilder().build()
-                );
-            }
-            case RuntimeSource runtimeSource -> {
-                builder.setRuntimeSource(
-                    SourcesProtobuf.RuntimeSource.newBuilder().build()
-                );
-            }
-            case FileFragmentSource fileFragmentSource -> {
-                builder.setFileFragmentSource(
-                    serializeFileFragmentSource(fileFragmentSource, parentSource)
-                );
-            }
-            default -> {
-                throw new UnsupportedOperationException("Unhandled source: " + source);
-            }
-        }
-
-        return builder.build();
-    }
-
-    public static Source deserializeSource(
-        SourcesProtobuf.Source sourceProtobuf,
-        Source parentSource
-    ) {
-        return deserializeSource(sourceProtobuf, Optional.of(parentSource));
-    }
-
-    public static Source deserializeSource(
-        SourcesProtobuf.Source sourceProtobuf,
-        Optional<Source> parentSource
-    ) {
-        return switch (sourceProtobuf.getValueCase()) {
-            case NULL_SOURCE ->
-                Sources.NULL;
-
-            case RUNTIME_SOURCE ->
-                Sources.RUNTIME;
-
-            case FILE_FRAGMENT_SOURCE ->
-                deserializeFileFragmentSource(
-                    sourceProtobuf.getFileFragmentSource(),
-                    parentSource
-                );
-
-            case VALUE_NOT_SET -> {
-                throw new UnsupportedOperationException("TODO");
-            }
-        };
-    }
-
-    private static SourcesProtobuf.FileFragmentSource serializeFileFragmentSource(
-        FileFragmentSource source,
-        Optional<Source> parentSource
-    ) {
-        var builder = SourcesProtobuf.FileFragmentSource.newBuilder();
-
-        var sourceTextName = source.sourceRange().sourceText().name();
-        if (!(
-            parentSource.isPresent() &&
-                parentSource.get() instanceof FileFragmentSource(
-                    SourceRange parentSourceRange) &&
-                parentSourceRange.sourceText().name().equals(sourceTextName)
-        )) {
-            builder.setSourceText(
-                SourcesProtobuf.SourceText.newBuilder()
-                    .setName(sourceTextName)
-                    .setContents(source.sourceRange().sourceText().charSequence().toString())
-                    .build()
-            );
-        }
-
-        builder.setStartCharacterIndex(source.sourceRange().start().characterIndex());
-        builder.setEndCharacterIndex(source.sourceRange().end().characterIndex());
-
-        return builder.build();
-    }
-
-    private static FileFragmentSource deserializeFileFragmentSource(
-        SourcesProtobuf.FileFragmentSource sourceProtobuf,
-        Optional<Source> parentSource
-    ) {
-        SourceText sourceText;
-        if (sourceProtobuf.hasSourceText()) {
-            sourceText = SourceText.fromString(
-                sourceProtobuf.getSourceText().getName(),
-                sourceProtobuf.getSourceText().getContents()
-            );
-        } else {
-            // TODO: handle missing parent
-            sourceText = ((FileFragmentSource) parentSource.orElseThrow()).sourceRange().sourceText();
-        }
-
-        var start = new SourcePosition(sourceText, sourceProtobuf.getStartCharacterIndex());
-        var end = new SourcePosition(sourceText, sourceProtobuf.getEndCharacterIndex());
-        return new FileFragmentSource(new SourceRange(sourceText, start, end));
-    }
-}
diff --git a/src/test/java/org/shedlang/compiler/patio/serialization/PatioToProtobufTests.java b/src/test/java/org/shedlang/compiler/patio/serialization/PatioToProtobufTests.java
deleted file mode 100644
index d75016cb..00000000
--- a/src/test/java/org/shedlang/compiler/patio/serialization/PatioToProtobufTests.java
+++ /dev/null
@@ -1,151 +0,0 @@
-package org.shedlang.compiler.patio.serialization;
-
-import com.google.protobuf.InvalidProtocolBufferException;
-import org.shedlang.compiler.patio.PatioCompilationUnit;
-import org.shedlang.compiler.patio.PatioCompilationUnitElement;
-import org.shedlang.compiler.patio.instructions.PatioInstruction;
-import org.shedlang.compiler.patio.operands.PatioOperand;
-import org.shedlang.compiler.patio.protobuf.PatioProtobuf;
-import org.shedlang.compiler.patio.types.PatioDataLayout;
-import org.shedlang.compiler.patio.types.PatioDataValue;
-import org.shedlang.compiler.patio.types.PatioType;
-import org.shedlang.compiler.patio.values.PatioDataPtrValue;
-import org.shedlang.compiler.patio.values.PatioIntValue;
-import org.shedlang.compiler.sources.Source;
-
-public class PatioToProtobufTests extends PatioSerializationTests {
-    @Override
-    protected byte[] serializeCompilationUnit(PatioCompilationUnit value) {
-        return PatioToProtobuf.serializeCompilationUnit(value).toByteArray();
-    }
-
-    @Override
-    protected PatioCompilationUnit deserializeCompilationUnit(byte[] buffer) {
-        try {
-            var valueProtobuf = PatioProtobuf.PatioCompilationUnit.parseFrom(buffer);
-            return PatioToProtobuf.deserializeCompilationUnit(valueProtobuf);
-        } catch (InvalidProtocolBufferException exception) {
-            throw new RuntimeException(exception);
-        }
-    }
-
-    @Override
-    protected byte[] serializeCompilationUnitElement(PatioCompilationUnitElement value, Source parentSource) {
-        return PatioToProtobuf.serializeCompilationUnitElement(value, parentSource).toByteArray();
-    }
-
-    @Override
-    protected PatioCompilationUnitElement deserializeCompilationUnitElement(byte[] buffer, Source parentSource) {
-        try {
-            var valueProtobuf = PatioProtobuf.PatioCompilationUnitElement.parseFrom(buffer);
-            return PatioToProtobuf.deserializeCompilationUnitElement(valueProtobuf, parentSource);
-        } catch (InvalidProtocolBufferException exception) {
-            throw new RuntimeException(exception);
-        }
-    }
-
-    @Override
-    protected byte[] serializeInstruction(PatioInstruction value, Source parentSource) {
-        return PatioToProtobuf.serializeInstruction(value, parentSource).toByteArray();
-    }
-
-    @Override
-    protected PatioInstruction deserializeInstruction(byte[] buffer, Source parentSource) {
-        try {
-            var valueProtobuf = PatioProtobuf.PatioInstruction.parseFrom(buffer);
-            return PatioToProtobuf.deserializeInstruction(valueProtobuf, parentSource);
-        } catch (InvalidProtocolBufferException exception) {
-            throw new RuntimeException(exception);
-        }
-    }
-
-    @Override
-    protected byte[] serializeOperand(PatioOperand value) {
-        return PatioToProtobuf.serializeOperand(value).toByteArray();
-    }
-
-    @Override
-    protected PatioOperand deserializeOperand(byte[] buffer) {
-        try {
-            var valueProtobuf = PatioProtobuf.PatioOperand.parseFrom(buffer);
-            return PatioToProtobuf.deserializeOperand(valueProtobuf);
-        } catch (InvalidProtocolBufferException exception) {
-            throw new RuntimeException(exception);
-        }
-    }
-
-    @Override
-    protected byte[] serializeDataPtrValue(PatioDataPtrValue value) {
-        return PatioToProtobuf.serializeDataPtrValue(value).toByteArray();
-    }
-
-    @Override
-    protected PatioDataPtrValue deserializeDataPtrValue(byte[] buffer) {
-        try {
-            var valueProtobuf = PatioProtobuf.PatioDataPtrValue.parseFrom(buffer);
-            return PatioToProtobuf.deserializeDataPtrValue(valueProtobuf);
-        } catch (InvalidProtocolBufferException exception) {
-            throw new RuntimeException(exception);
-        }
-    }
-
-    @Override
-    protected byte[] serializeIntValue(PatioIntValue value) {
-        return PatioToProtobuf.serializeIntValue(value).toByteArray();
-    }
-
-    @Override
-    protected PatioIntValue deserializeIntValue(byte[] buffer) {
-        try {
-            var valueProtobuf = PatioProtobuf.PatioIntValue.parseFrom(buffer);
-            return PatioToProtobuf.deserializeIntValue(valueProtobuf);
-        } catch (InvalidProtocolBufferException exception) {
-            throw new RuntimeException(exception);
-        }
-    }
-
-    @Override
-    protected byte[] serializeType(PatioType value) {
-        return PatioToProtobuf.serializeType(value).toByteArray();
-    }
-
-    @Override
-    protected PatioType deserializeType(byte[] buffer) {
-        try {
-            var valueProtobuf = PatioProtobuf.PatioType.parseFrom(buffer);
-            return PatioToProtobuf.deserializeType(valueProtobuf);
-        } catch (InvalidProtocolBufferException exception) {
-            throw new RuntimeException(exception);
-        }
-    }
-
-    @Override
-    protected byte[] serializeDataLayout(PatioDataLayout value) {
-        return PatioToProtobuf.serializeDataLayout(value).toByteArray();
-    }
-
-    @Override
-    protected PatioDataLayout deserializeDataLayout(byte[] buffer) {
-        try {
-            var valueProtobuf = PatioProtobuf.PatioDataLayout.parseFrom(buffer);
-            return PatioToProtobuf.deserializeDataLayout(valueProtobuf);
-        } catch (InvalidProtocolBufferException exception) {
-            throw new RuntimeException(exception);
-        }
-    }
-
-    @Override
-    protected byte[] serializeDataValue(PatioDataValue value) {
-        return PatioToProtobuf.serializeDataValue(value).toByteArray();
-    }
-
-    @Override
-    protected PatioDataValue deserializeDataValue(byte[] buffer) {
-        try {
-            var valueProtobuf = PatioProtobuf.PatioDataValue.parseFrom(buffer);
-            return PatioToProtobuf.deserializeDataValue(valueProtobuf);
-        } catch (InvalidProtocolBufferException exception) {
-            throw new RuntimeException(exception);
-        }
-    }
-}
diff --git a/src/test/java/org/shedlang/compiler/sources/serialization/SourceToFlatbuffersTests.java b/src/test/java/org/shedlang/compiler/sources/serialization/SourceToFlatbuffersTests.java
index 31d20149..731c302d 100644
--- a/src/test/java/org/shedlang/compiler/sources/serialization/SourceToFlatbuffersTests.java
+++ b/src/test/java/org/shedlang/compiler/sources/serialization/SourceToFlatbuffersTests.java
@@ -1,10 +1,8 @@
 package org.shedlang.compiler.sources.serialization;
 
 import com.google.flatbuffers.FlatBufferBuilder;
-import com.google.protobuf.InvalidProtocolBufferException;
 import org.shedlang.compiler.sources.SourceSerializationTests;
 import org.shedlang.compiler.sources.flatbuffers.SourceFbs;
-import org.shedlang.compiler.sources.protobuf.SourcesProtobuf;
 
 import java.nio.ByteBuffer;
 
diff --git a/src/test/java/org/shedlang/compiler/sources/serialization/SourceToProtobufTests.java b/src/test/java/org/shedlang/compiler/sources/serialization/SourceToProtobufTests.java
deleted file mode 100644
index cd77ec5c..00000000
--- a/src/test/java/org/shedlang/compiler/sources/serialization/SourceToProtobufTests.java
+++ /dev/null
@@ -1,25 +0,0 @@
-package org.shedlang.compiler.sources.serialization;
-
-import com.google.protobuf.InvalidProtocolBufferException;
-import org.shedlang.compiler.sources.SourceSerializationTests;
-import org.shedlang.compiler.sources.protobuf.SourcesProtobuf;
-
-public class SourceToProtobufTests extends SourceSerializationTests {
-    public SourceToProtobufTests() {
-        super(
-            (source, parentSource) -> {
-                var sourceProtobuf = SourceToProtobuf.serializeSource(source, parentSource);
-                return sourceProtobuf.toByteArray();
-            },
-
-            (serializedSource, parentSource) -> {
-                try {
-                    var sourceProtobuf = SourcesProtobuf.Source.parseFrom(serializedSource);
-                    return SourceToProtobuf.deserializeSource(sourceProtobuf, parentSource);
-                } catch (InvalidProtocolBufferException exception) {
-                    throw new RuntimeException(exception);
-                }
-            }
-        );
-    }
-}