Serialize Patio instructions to Protobuf

2 files changed, 1480 insertions, 4 deletions

diff --git a/src/main/java/org/shedlang/compiler/patio/protobuf/PatioToProtobuf.java b/src/main/java/org/shedlang/compiler/patio/protobuf/PatioToProtobuf.java
index f3142428..56cbc260 100644
--- a/src/main/java/org/shedlang/compiler/patio/protobuf/PatioToProtobuf.java
+++ b/src/main/java/org/shedlang/compiler/patio/protobuf/PatioToProtobuf.java
@@ -1,6 +1,7 @@
 package org.shedlang.compiler.patio.protobuf;
 
 import org.shedlang.compiler.patio.*;
+import org.shedlang.compiler.patio.instructions.*;
 import org.shedlang.compiler.patio.operands.*;
 import org.shedlang.compiler.patio.types.*;
 import org.shedlang.compiler.patio.values.*;
@@ -301,6 +302,968 @@ public class PatioToProtobuf {
         };
     }
 
+    // == 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))
+                .collect(Collectors.toList()),
+            instructionProtobuf.getResultsList().stream()
+                .map(PatioToProtobuf::deserializeOperand)
+                .collect(Collectors.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)
+                .collect(Collectors.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)
+                .collect(Collectors.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)
+                .collect(Collectors.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))
+                .collect(Collectors.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)
+                .collect(Collectors.toList()),
+            deserializeOperand(instructionProtobuf.getValue()),
+            instructionProtobuf.getCasesList().stream()
+                .map(caseProtobuf -> deserializeSwitchCase(caseProtobuf, source))
+                .collect(Collectors.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)
+                .collect(Collectors.toList()),
+            instructionProtobuf.getCatchClausesList().stream()
+                .map(catchClauseProtobuf -> deserializeCatchClause(catchClauseProtobuf, source))
+                .collect(Collectors.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) {
@@ -338,8 +1301,7 @@ public class PatioToProtobuf {
             }
 
             case PatioLocalRef localRef -> {
-                var localRefBuilder = builder.getLocalRefBuilder();
-                localRefBuilder.setName(localRef.name());
+                builder.setLocalRef(serializeLocalRef(localRef));
             }
         }
 
@@ -373,13 +1335,23 @@ public class PatioToProtobuf {
                 );
 
             case LOCAL_REF ->
-                new PatioLocalRef(operandProtobuf.getLocalRef().getName());
+                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) {
diff --git a/src/test/java/org/shedlang/compiler/patio/protobuf/PatioToProtobufTests.java b/src/test/java/org/shedlang/compiler/patio/protobuf/PatioToProtobufTests.java
index 03ded426..6e889390 100644
--- a/src/test/java/org/shedlang/compiler/patio/protobuf/PatioToProtobufTests.java
+++ b/src/test/java/org/shedlang/compiler/patio/protobuf/PatioToProtobufTests.java
@@ -2,7 +2,6 @@ package org.shedlang.compiler.patio.protobuf;
 
 import org.junit.jupiter.api.Test;
 import org.shedlang.compiler.patio.PatioFunctionDeclaration;
-import org.shedlang.compiler.patio.PatioTesting;
 import org.shedlang.compiler.patio.PatioVisibility;
 import org.shedlang.compiler.patio.instructions.Patio;
 import org.shedlang.compiler.patio.types.PatioDataLayouts;
@@ -11,6 +10,7 @@ import org.shedlang.compiler.patio.types.PatioTypes;
 import org.shedlang.compiler.sources.Sources;
 
 import java.util.List;
+import java.util.Optional;
 
 import static org.zwobble.precisely.AssertThat.assertThat;
 import static org.zwobble.precisely.Matchers.equalTo;
@@ -97,6 +97,510 @@ public class PatioToProtobufTests {
         assertThat(deserializedElement, equalTo(element));
     }
 
+    // == Instructions ==
+
+    @Test
+    public void canSerializeBlock() {
+        var instruction = Patio.block(
+            List.of(
+                Patio.localStore(Patio.localRef("x1"), Patio.intConst(1)),
+                Patio.localStore(Patio.localRef("y1"), Patio.intConst(2))
+            ),
+            List.of(
+                Patio.localRef("x1"),
+                Patio.localRef("y1")
+            )
+        );
+
+        var deserializedInstruction = PatioToProtobuf.deserializeInstruction(
+            PatioToProtobuf.serializeInstruction(instruction, Sources.NULL),
+            Sources.NULL
+        );
+
+        assertThat(deserializedInstruction, equalTo(instruction));
+    }
+
+    @Test
+    public void canSerializeBoolToInt() {
+        var instruction = Patio.boolToInt(Patio.localRef("destination"), Patio.localRef("value"));
+
+        var deserializedInstruction = PatioToProtobuf.deserializeInstruction(
+            PatioToProtobuf.serializeInstruction(instruction, Sources.NULL),
+            Sources.NULL
+        );
+
+        assertThat(deserializedInstruction, equalTo(instruction));
+    }
+
+    @Test
+    public void canSerializeCallWithoutDestination() {
+        var instruction = Patio.call(
+            Optional.empty(),
+            "f",
+            List.of(Patio.localRef("a"), Patio.localRef("b"), Patio.localRef("c"))
+        );
+
+        var deserializedInstruction = PatioToProtobuf.deserializeInstruction(
+            PatioToProtobuf.serializeInstruction(instruction, Sources.NULL),
+            Sources.NULL
+        );
+
+        assertThat(deserializedInstruction, equalTo(instruction));
+    }
+
+    @Test
+    public void canSerializeCallWithDestination() {
+        var instruction = Patio.call(
+            Optional.of(Patio.localRef("destination")),
+            "f",
+            List.of(Patio.localRef("a"), Patio.localRef("b"), Patio.localRef("c"))
+        );
+
+        var deserializedInstruction = PatioToProtobuf.deserializeInstruction(
+            PatioToProtobuf.serializeInstruction(instruction, Sources.NULL),
+            Sources.NULL
+        );
+
+        assertThat(deserializedInstruction, equalTo(instruction));
+    }
+
+    @Test
+    public void canSerializeCallPointer() {
+        var instruction = Patio.callPointer(
+            Patio.localRef("destination"),
+            Patio.localRef("f"),
+            List.of(Patio.localRef("a"), Patio.localRef("b"), Patio.localRef("c"))
+        );
+
+        var deserializedInstruction = PatioToProtobuf.deserializeInstruction(
+            PatioToProtobuf.serializeInstruction(instruction, Sources.NULL),
+            Sources.NULL
+        );
+
+        assertThat(deserializedInstruction, equalTo(instruction));
+    }
+
+    @Test
+    public void canSerializeDataPtrToInt() {
+        var instruction = Patio.dataPtrToInt(Patio.localRef("destination"), Patio.localRef("value"));
+
+        var deserializedInstruction = PatioToProtobuf.deserializeInstruction(
+            PatioToProtobuf.serializeInstruction(instruction, Sources.NULL),
+            Sources.NULL
+        );
+
+        assertThat(deserializedInstruction, equalTo(instruction));
+    }
+
+    @Test
+    public void canSerializeIf() {
+        var instruction = Patio.if_(
+            List.of(
+                Patio.localRef("x"),
+                Patio.localRef("y")
+            ),
+            Patio.localRef("condition"),
+            Patio.block(
+                List.of(
+                    Patio.localStore(Patio.localRef("x1"), Patio.intConst(1)),
+                    Patio.localStore(Patio.localRef("y1"), Patio.intConst(2))
+                ),
+                List.of(
+                    Patio.localRef("x1"),
+                    Patio.localRef("y1")
+                )
+            ),
+            Patio.block(
+                List.of(
+                    Patio.localStore(Patio.localRef("x2"), Patio.intConst(11)),
+                    Patio.localStore(Patio.localRef("y2"), Patio.intConst(12))
+                ),
+                List.of(
+                    Patio.localRef("x2"),
+                    Patio.localRef("y2")
+                )
+            )
+        );
+
+        var deserializedInstruction = PatioToProtobuf.deserializeInstruction(
+            PatioToProtobuf.serializeInstruction(instruction, Sources.NULL),
+            Sources.NULL
+        );
+
+        assertThat(deserializedInstruction, equalTo(instruction));
+    }
+
+    @Test
+    public void canSerializeIntAdd() {
+        var instruction = Patio.intAdd(
+            Patio.localRef("destination"),
+            Patio.localRef("left"),
+            Patio.localRef("right")
+        );
+
+        var deserializedInstruction = PatioToProtobuf.deserializeInstruction(
+            PatioToProtobuf.serializeInstruction(instruction, Sources.NULL),
+            Sources.NULL
+        );
+
+        assertThat(deserializedInstruction, equalTo(instruction));
+    }
+
+    @Test
+    public void canSerializeIntEquals() {
+        var instruction = Patio.intEquals(
+            Patio.localRef("destination"),
+            Patio.localRef("left"),
+            Patio.localRef("right")
+        );
+
+        var deserializedInstruction = PatioToProtobuf.deserializeInstruction(
+            PatioToProtobuf.serializeInstruction(instruction, Sources.NULL),
+            Sources.NULL
+        );
+
+        assertThat(deserializedInstruction, equalTo(instruction));
+    }
+
+    @Test
+    public void canSerializeIntNotEqual() {
+        var instruction = Patio.intNotEqual(
+            Patio.localRef("destination"),
+            Patio.localRef("left"),
+            Patio.localRef("right")
+        );
+
+        var deserializedInstruction = PatioToProtobuf.deserializeInstruction(
+            PatioToProtobuf.serializeInstruction(instruction, Sources.NULL),
+            Sources.NULL
+        );
+
+        assertThat(deserializedInstruction, equalTo(instruction));
+    }
+
+    @Test
+    public void canSerializeIntSub() {
+        var instruction = Patio.intSub(
+            Patio.localRef("destination"),
+            Patio.localRef("left"),
+            Patio.localRef("right")
+        );
+
+        var deserializedInstruction = PatioToProtobuf.deserializeInstruction(
+            PatioToProtobuf.serializeInstruction(instruction, Sources.NULL),
+            Sources.NULL
+        );
+
+        assertThat(deserializedInstruction, equalTo(instruction));
+    }
+
+    @Test
+    public void canSerializeIntToBool() {
+        var instruction = Patio.intToBool(Patio.localRef("destination"), Patio.localRef("value"));
+
+        var deserializedInstruction = PatioToProtobuf.deserializeInstruction(
+            PatioToProtobuf.serializeInstruction(instruction, Sources.NULL),
+            Sources.NULL
+        );
+
+        assertThat(deserializedInstruction, equalTo(instruction));
+    }
+
+    @Test
+    public void canSerializeIntToDataPtr() {
+        var instruction = Patio.intToDataPtr(
+            Patio.localRef("destination"),
+            Patio.localRef("value")
+        );
+
+        var deserializedInstruction = PatioToProtobuf.deserializeInstruction(
+            PatioToProtobuf.serializeInstruction(instruction, Sources.NULL),
+            Sources.NULL
+        );
+
+        assertThat(deserializedInstruction, equalTo(instruction));
+    }
+
+    @Test
+    public void canSerializeLocalStore() {
+        var instruction = Patio.localStore(
+            Patio.localRef("destination"),
+            Patio.localRef("x")
+        );
+
+        var deserializedInstruction = PatioToProtobuf.deserializeInstruction(
+            PatioToProtobuf.serializeInstruction(instruction, Sources.NULL),
+            Sources.NULL
+        );
+
+        assertThat(deserializedInstruction, equalTo(instruction));
+    }
+
+    @Test
+    public void canSerializeLoop() {
+        var instruction = Patio.loop(
+            List.of(
+                Patio.localStore(Patio.localRef("x"), Patio.intConst(1))
+            )
+        );
+
+        var deserializedInstruction = PatioToProtobuf.deserializeInstruction(
+            PatioToProtobuf.serializeInstruction(instruction, Sources.NULL),
+            Sources.NULL
+        );
+
+        assertThat(deserializedInstruction, equalTo(instruction));
+    }
+
+    @Test
+    public void canSerializeLoopBreak() {
+        var instruction = Patio.loopBreak();
+
+        var deserializedInstruction = PatioToProtobuf.deserializeInstruction(
+            PatioToProtobuf.serializeInstruction(instruction, Sources.NULL),
+            Sources.NULL
+        );
+
+        assertThat(deserializedInstruction, equalTo(instruction));
+    }
+
+    @Test
+    public void canSerializeLoopContinue() {
+        var instruction = Patio.loopContinue();
+
+        var deserializedInstruction = PatioToProtobuf.deserializeInstruction(
+            PatioToProtobuf.serializeInstruction(instruction, Sources.NULL),
+            Sources.NULL
+        );
+
+        assertThat(deserializedInstruction, equalTo(instruction));
+    }
+
+    @Test
+    public void canSerializeMemoryLoad() {
+        var instruction = Patio.memoryLoad(
+            Patio.localRef("destination"),
+            Patio.localRef("pointer"),
+            PatioDataLayouts.struct(List.of(PatioDataLayouts.INT, PatioDataLayouts.INT, PatioDataLayouts.BYTE)),
+            List.of(1)
+        );
+
+        var deserializedInstruction = PatioToProtobuf.deserializeInstruction(
+            PatioToProtobuf.serializeInstruction(instruction, Sources.NULL),
+            Sources.NULL
+        );
+
+        assertThat(deserializedInstruction, equalTo(instruction));
+    }
+
+    @Test
+    public void canSerializeMemoryStore() {
+        var instruction = Patio.memoryStore(
+            Patio.localRef("pointer"),
+            PatioDataLayouts.struct(List.of(PatioDataLayouts.INT, PatioDataLayouts.INT, PatioDataLayouts.BYTE)),
+            List.of(1),
+            Patio.localRef("value")
+        );
+
+        var deserializedInstruction = PatioToProtobuf.deserializeInstruction(
+            PatioToProtobuf.serializeInstruction(instruction, Sources.NULL),
+            Sources.NULL
+        );
+
+        assertThat(deserializedInstruction, equalTo(instruction));
+    }
+
+    @Test
+    public void canSerializeResume() {
+        var instruction = Patio.resume(Patio.localRef("value"));
+
+        var deserializedInstruction = PatioToProtobuf.deserializeInstruction(
+            PatioToProtobuf.serializeInstruction(instruction, Sources.NULL),
+            Sources.NULL
+        );
+
+        assertThat(deserializedInstruction, equalTo(instruction));
+    }
+
+    @Test
+    public void canSerializeReturn() {
+        var instruction = Patio.return_(Patio.localRef("value"));
+
+        var deserializedInstruction = PatioToProtobuf.deserializeInstruction(
+            PatioToProtobuf.serializeInstruction(instruction, Sources.NULL),
+            Sources.NULL
+        );
+
+        assertThat(deserializedInstruction, equalTo(instruction));
+    }
+
+    @Test
+    public void canSerializeReturnVoid() {
+        var instruction = Patio.returnVoid();
+
+        var deserializedInstruction = PatioToProtobuf.deserializeInstruction(
+            PatioToProtobuf.serializeInstruction(instruction, Sources.NULL),
+            Sources.NULL
+        );
+
+        assertThat(deserializedInstruction, equalTo(instruction));
+    }
+
+    @Test
+    public void canSerializeSwitch() {
+        var instruction = Patio.switch_(
+            List.of(
+                Patio.localRef("x"),
+                Patio.localRef("y")
+            ),
+            Patio.localRef("value"),
+            List.of(
+                Patio.switchCase(
+                    1,
+                    Patio.block(
+                        List.of(
+                            Patio.localStore(Patio.localRef("x1"), Patio.intConst(11)),
+                            Patio.localStore(Patio.localRef("y1"), Patio.intConst(12))
+                        ),
+                        List.of(
+                            Patio.localRef("x1"),
+                            Patio.localRef("y1")
+                        )
+                    )
+                ),
+                Patio.switchCase(
+                    2,
+                    Patio.block(
+                        List.of(
+                            Patio.localStore(Patio.localRef("x2"), Patio.intConst(21)),
+                            Patio.localStore(Patio.localRef("y2"), Patio.intConst(22))
+                        ),
+                        List.of(
+                            Patio.localRef("x2"),
+                            Patio.localRef("y2")
+                        )
+                    )
+                )
+            ),
+            Patio.block(
+                List.of(
+                    Patio.localStore(Patio.localRef("x3"), Patio.intConst(31)),
+                    Patio.localStore(Patio.localRef("y3"), Patio.intConst(32))
+                ),
+                List.of(
+                    Patio.localRef("x3"),
+                    Patio.localRef("y3")
+                )
+            )
+        );
+
+        var deserializedInstruction = PatioToProtobuf.deserializeInstruction(
+            PatioToProtobuf.serializeInstruction(instruction, Sources.NULL),
+            Sources.NULL
+        );
+
+        assertThat(deserializedInstruction, equalTo(instruction));
+    }
+
+    @Test
+    public void canSerializeThrow() {
+        var instruction = Patio.throw_("Error", Patio.localRef("value"));
+
+        var deserializedInstruction = PatioToProtobuf.deserializeInstruction(
+            PatioToProtobuf.serializeInstruction(instruction, Sources.NULL),
+            Sources.NULL
+        );
+
+        assertThat(deserializedInstruction, equalTo(instruction));
+    }
+
+    @Test
+    public void canSerializeTry() {
+        var instruction = Patio.try_(
+            List.of(Patio.localRef("x"), Patio.localRef("y")),
+            List.of(
+                Patio.catchClause(
+                    "Error1",
+                    Patio.localRef("a1"),
+                    Patio.block(
+                        List.of(
+                            Patio.localStore(Patio.localRef("xCatch1"), Patio.intConst(11)),
+                            Patio.localStore(Patio.localRef("yCatch1"), Patio.intConst(12))
+                        ),
+                        List.of(Patio.localRef("xCatch1"), Patio.localRef("yCatch1"))
+                    )
+                ),
+                Patio.catchClause(
+                    "Error2",
+                    Patio.localRef("a2"),
+                    Patio.block(
+                        List.of(
+                            Patio.localStore(Patio.localRef("xCatch2"), Patio.intConst(21)),
+                            Patio.localStore(Patio.localRef("yCatch2"), Patio.intConst(22))
+                        ),
+                        List.of(Patio.localRef("xCatch2"), Patio.localRef("yCatch2"))
+                    )
+                )
+            ),
+            Patio.block(
+                List.of(
+                    Patio.localStore(Patio.localRef("xTry"), Patio.intConst(31)),
+                    Patio.localStore(Patio.localRef("yTry"), Patio.intConst(32))
+                ),
+                List.of(Patio.localRef("xTry"), Patio.localRef("yTry"))
+            )
+        );
+
+        var deserializedInstruction = PatioToProtobuf.deserializeInstruction(
+            PatioToProtobuf.serializeInstruction(instruction, Sources.NULL),
+            Sources.NULL
+        );
+
+        assertThat(deserializedInstruction, equalTo(instruction));
+    }
+
+    @Test
+    public void canSerializeUnreachable() {
+        var instruction = Patio.unreachable();
+
+        var deserializedInstruction = PatioToProtobuf.deserializeInstruction(
+            PatioToProtobuf.serializeInstruction(instruction, Sources.NULL),
+            Sources.NULL
+        );
+
+        assertThat(deserializedInstruction, equalTo(instruction));
+    }
+
+    @Test
+    public void canSerializeVarLoad() {
+        var instruction = Patio.varLoad(
+            Patio.localRef("destination"),
+            Patio.localRef("v")
+        );
+
+        var deserializedInstruction = PatioToProtobuf.deserializeInstruction(
+            PatioToProtobuf.serializeInstruction(instruction, Sources.NULL),
+            Sources.NULL
+        );
+
+        assertThat(deserializedInstruction, equalTo(instruction));
+    }
+
+    @Test
+    public void canSerializeVarStore() {
+        var instruction = Patio.varStore(
+            Patio.localRef("destination"),
+            Patio.localRef("value")
+        );
+
+        var deserializedInstruction = PatioToProtobuf.deserializeInstruction(
+            PatioToProtobuf.serializeInstruction(instruction, Sources.NULL),
+            Sources.NULL
+        );
+
+        assertThat(deserializedInstruction, equalTo(instruction));
+    }
+
     // == Operands ==
 
     @Test